QCM : Programmation en C — 21 questions

Questions et réponses du QCM

1. Concernant la structure et la compilation d’un programme C, cochez la (les) proposition(s) exacte(s) :

La commande `gcc programme.c -o programme` lance directement l’exécutable produit.
La commande `./programme` transforme le fichier `.c` en exécutable.
La compilation et l’exécution désignent deux étapes différentes.
La fonction `main` constitue le point de départ obligatoire d’un programme C.
La déclaration usuelle de `main` est `int main()`.

La compilation et l’exécution désignent deux étapes différentes. · La fonction `main` constitue le point de départ obligatoire d’un programme C. · La déclaration usuelle de `main` est `int main()`.

Explication

La fonction `main` constitue le point d’entrée d’un programme C et sa déclaration usuelle renvoie un entier. La compilation crée l’exécutable, tandis que `./programme` sert à le lancer.

2. Un fichier `programme.c` doit être transformé puis lancé : quelles propositions décrivent correctement ces étapes ?

La commande `./programme` peut être utilisée après la compilation.
La commande `./programme` exécute le fichier compilé.
La compilation transforme directement l’exécutable en fichier `.c`.
La commande `gcc programme.c -o programme` réalise l’exécution du programme.
La commande `gcc programme.c -o programme` produit un exécutable.

La commande `./programme` peut être utilisée après la compilation. · La commande `./programme` exécute le fichier compilé. · La commande `gcc programme.c -o programme` produit un exécutable.

Explication

La commande `gcc programme.c -o programme` compile le fichier et produit l’exécutable nommé `programme`. La commande `./programme` exécute cet exécutable, sans effectuer la compilation.

3. À propos des variables en C, quelle(s) est(sont) la(les) proposition(s) exacte(s) ?

Le type d’une variable C peut changer dynamiquement pendant l’exécution.
Une variable correspond à une zone mémoire identifiée par un nom.
Une variable conserve son type pendant l’exécution du programme.
Une variable est nécessairement une fonction réservée aux entrées-sorties.
Le langage C applique un typage statique aux variables.

Une variable correspond à une zone mémoire identifiée par un nom. · Une variable conserve son type pendant l’exécution du programme. · Le langage C applique un typage statique aux variables.

Explication

En C, une variable est une zone mémoire identifiée par un nom, dont le type reste fixe pendant l’exécution. Cette propriété correspond au typage statique ; elle ne signifie pas que toute valeur possède un type changeant dynamiquement.

4. Concernant les types essentiels du langage C, cochez la (les) proposition(s) exacte(s) :

Le type `double` représente un flottant de 64 bits.
Le type `void` indique l’absence de valeur de retour.
Le type `char` représente l’absence de valeur de retour.
Le type `int` représente des nombres entiers.
Le type `float` représente un flottant de 64 bits.

Le type `double` représente un flottant de 64 bits. · Le type `void` indique l’absence de valeur de retour. · Le type `int` représente des nombres entiers.

Explication

`double` représente un flottant de 64 bits, alors que `float` représente un flottant de 32 bits. `int` concerne les entiers, et `void` indique l’absence de valeur de retour.

5. Quelles sont les réponses exactes au sujet des divisions en C ?

L’expression 7.0/27.0 / 2 produit un résultat flottant.
L’expression 7.0/27.0 / 2 réalise une division entière.
L’expression 3/23 / 2 vaut 11 lorsque ses deux opérandes sont entières.
L’expression 3/23 / 2 vaut 1.51.5 avec deux opérandes entières.
Une opération entre un entier et un flottant peut produire un flottant.

L’expression $$7.0 / 2$$ produit un résultat flottant. · L’expression $$3 / 2$$ vaut $$1$$ lorsque ses deux opérandes sont entières. · Une opération entre un entier et un flottant peut produire un flottant.

Explication

La division de deux entiers réalise une division entière : 3/2=13 / 2 = 1. La présence d’un flottant produit un résultat flottant, comme 7.0/2=3.57.0 / 2 = 3.5.

6. Concernant les opérateurs d’affectation et d’égalité en C, quelles propositions sont exactes ?

L’opérateur `==` compare deux valeurs pour tester leur égalité.
L’opérateur `==` modifie la valeur d’une variable comparée.
L’opérateur `=` réalise une affectation.
Une affectation peut modifier la valeur stockée dans une variable.
L’opérateur `=` réalise une comparaison d’égalité.

L’opérateur `==` compare deux valeurs pour tester leur égalité. · L’opérateur `=` réalise une affectation. · Une affectation peut modifier la valeur stockée dans une variable.

Explication

L’opérateur `=` affecte une valeur à une variable, tandis que `==` compare deux valeurs sans affectation. La comparaison d’égalité ne modifie donc pas la variable comparée.

7. À propos de l’évaluation paresseuse des expressions booléennes en C :

Dans `x || y`, `y` peut ne pas être évalué lorsque `x` est vrai.
Dans `x && y`, `y` peut ne pas être évalué lorsque `x` est faux.
L’évaluation paresseuse concerne les opérateurs logiques `&&` et `||`.
Dans `x && y`, `y` cesse d’être évalué lorsque `x` est vrai.
Dans `x || y`, `y` cesse d’être évalué lorsque `x` est faux.

Dans `x || y`, `y` peut ne pas être évalué lorsque `x` est vrai. · Dans `x && y`, `y` peut ne pas être évalué lorsque `x` est faux. · L’évaluation paresseuse concerne les opérateurs logiques `&&` et `||`.

Explication

Avec `x && y`, l’évaluation de `y` s’arrête lorsque `x` est faux. Avec `x || y`, elle s’arrête lorsque `x` est vrai ; ces comportements relèvent de l’évaluation paresseuse.

8. Concernant les caractères et les chaînes en C, cochez la (les) proposition(s) exacte(s) :

La séquence `\t` représente une tabulation.
La séquence `\n` représente un retour à la ligne.
`"a"` désigne un caractère isolé écrit entre guillemets doubles.
`"abc"` désigne une chaîne écrite entre guillemets doubles.
`'a'` désigne un caractère écrit entre guillemets simples.

La séquence `\t` représente une tabulation. · La séquence `\n` représente un retour à la ligne. · `"abc"` désigne une chaîne écrite entre guillemets doubles. · `'a'` désigne un caractère écrit entre guillemets simples.

Explication

Un caractère s’écrit entre guillemets simples, comme `'a'`, tandis qu’une chaîne s’écrit entre guillemets doubles, comme `"abc"`. Les séquences `\n`, `\t` et `\0` désignent respectivement un retour à la ligne, une tabulation et le caractère nul.

9. Concernant les boucles while et for :

Une boucle for répète son corps tant que sa condition reste vraie.
Une boucle while transforme automatiquement sa condition en compteur.
Une boucle while répète son corps tant que sa condition est vraie.
Une boucle while regroupe obligatoirement une initialisation et une mise à jour.
Une boucle for regroupe une initialisation, une condition et une mise à jour.

Une boucle while répète son corps tant que sa condition est vraie. · Une boucle for regroupe une initialisation, une condition et une mise à jour.

Explication

Une boucle while poursuit son exécution tant que sa condition reste vraie, alors qu’une boucle for rassemble initialisation, condition et mise à jour. La boucle for n’est donc pas définie par une condition fausse au départ.

10. Dans une boucle C, cochez la (les) proposition(s) exacte(s) :

L’instruction break quitte immédiatement la boucle en cours.
L’instruction continue ignore la fin du tour courant.
L’instruction break passe au tour suivant sans quitter la boucle.
L’instruction continue arrête définitivement les appels récursifs.
L’instruction continue exécute le reste du tour avant de poursuivre.

L’instruction break quitte immédiatement la boucle en cours. · L’instruction continue ignore la fin du tour courant.

Explication

L’instruction break quitte immédiatement la boucle, tandis que continue conserve la boucle et passe au tour suivant en ignorant la fin du tour courant. Ainsi, continue ne termine pas la boucle.

11. Quelles sont les réponses exactes au sujet d’une fonction C ?

Une fonction C renvoie une valeur même lorsqu’aucun return n’est prévu.
Une fonction C contient un bloc d’instructions exécutables.
Une fonction C doit comporter au moins deux paramètres.
Une fonction C peut renvoyer une valeur avec l’instruction return.
Une fonction C associe un nom, des paramètres et un type de retour.

Une fonction C contient un bloc d’instructions exécutables. · Une fonction C peut renvoyer une valeur avec l’instruction return. · Une fonction C associe un nom, des paramètres et un type de retour.

Explication

Une fonction C possède un nom, des paramètres, un type de retour et un bloc d’instructions. Elle peut renvoyer une valeur à l’aide de return, mais ce retour n’est pas obligatoire dans toute définition.

12. Une fonction récursive correctement construite comprend :

Un cas de base capable d’arrêter les appels récursifs.
Un cas de base qui déclenche un nouvel appel récursif.
Un appel récursif qui conserve la même valeur à chaque étape.
Un appel récursif qui réduit progressivement le problème traité.
Une condition d’arrêt située après tous les appels récursifs.

Un cas de base capable d’arrêter les appels récursifs. · Un appel récursif qui réduit progressivement le problème traité.

Explication

Une fonction récursive doit comporter un cas de base pour arrêter les appels et un appel récursif qui réduit le problème. Un appel sur une valeur inchangée ne garantit pas cette réduction.

13. Concernant les tableaux C, cochez la (les) proposition(s) exacte(s) :

Le premier élément d’un tableau possède l’indice 0.
Dans t[3], l’expression t[3] désigne le troisième élément.
Un tableau contient plusieurs valeurs d’un même type.
Les éléments d’un tableau sont stockés consécutivement en mémoire.
Dans t[5], le premier élément est désigné par t[1].

Le premier élément d’un tableau possède l’indice 0. · Un tableau contient plusieurs valeurs d’un même type. · Les éléments d’un tableau sont stockés consécutivement en mémoire.

Explication

Un tableau regroupe plusieurs valeurs de même type dans des emplacements consécutifs, et son premier élément porte l’indice 0. Dans un tableau, t[2] désigne donc le troisième élément, pas le deuxième.

14. Parmi les propositions suivantes concernant les indices d’un tableau C, la(les)quelle(s) est(sont) exacte(s) ?

Le C ne vérifie pas automatiquement la validité des indices.
Un indice hors limites peut entraîner un comportement imprévisible.
Un indice hors limites peut provoquer une erreur de segmentation.
Un accès hors limites garantit une modification de la case t[4].
L’accès t[7] est valide dans un tableau déclaré int t[5].

Le C ne vérifie pas automatiquement la validité des indices. · Un indice hors limites peut entraîner un comportement imprévisible. · Un indice hors limites peut provoquer une erreur de segmentation.

Explication

Le langage C ne vérifie pas automatiquement les indices des tableaux. Un accès à t[7] dans int t[5] peut donc entraîner une modification mémoire, une erreur de segmentation ou un comportement imprévisible.

15. Les caractéristiques des chaînes de caractères en C comprennent :

Le caractère nul '\0' indique toujours le premier caractère visible.
Une chaîne de caractères se termine par le caractère nul '\0'.
La chaîne désignée par char* s = "Bonjour" est immuable.
Une chaîne de caractères est représentée par un tableau de char.
La déclaration char* s = "Bonjour" crée un tableau modifiable.

Une chaîne de caractères se termine par le caractère nul '\0'. · La chaîne désignée par char* s = "Bonjour" est immuable. · Une chaîne de caractères est représentée par un tableau de char.

Explication

Une chaîne C est un tableau de caractères terminé par le caractère nul '\0'. La déclaration char* s = "Bonjour" désigne une chaîne immuable, contrairement à un tableau de caractères modifiable.

16. Concernant les pointeurs en C :

Un pointeur int* peut contenir l’adresse d’une variable int.
Un pointeur est une variable qui contient une adresse mémoire.
L’expression p désigne directement la valeur entière pointée.
L’expression *p désigne la valeur située à l’adresse contenue dans p.
L’adresse d’une variable int est stockée dans une variable de type char*.

Un pointeur int* peut contenir l’adresse d’une variable int. · Un pointeur est une variable qui contient une adresse mémoire. · L’expression *p désigne la valeur située à l’adresse contenue dans p.

Explication

Un pointeur contient une adresse mémoire, tandis que l’expression *p désigne la valeur située à cette adresse. Ainsi, p et *p n’ont pas la même nature.

17. Quelles sont les réponses exactes au sujet de &x et *p en C ?

L’expression &x et l’expression *p désignent toujours la même donnée.
L’expression &x lit la valeur entière stockée dans x.
L’expression &x désigne l’adresse mémoire de la variable x.
L’expression *p produit nécessairement l’adresse de la variable x.
L’expression *p désigne la valeur située à l’adresse contenue dans p.

L’expression &x désigne l’adresse mémoire de la variable x. · L’expression *p désigne la valeur située à l’adresse contenue dans p.

Explication

L’expression &x obtient l’adresse mémoire de x, tandis que *p accède à la valeur située à l’adresse contenue dans p. Ces opérateurs remplissent donc des fonctions différentes.

18. Concernant l’allocation dynamique d’un entier :

L’instruction `int* p = malloc(sizeof(int))` réserve une zone pour un entier.
L’appel `free(p)` libère la zone mémoire précédemment allouée.
La valeur de l’entier alloué peut être manipulée avec l’expression `*p`.
L’expression `free(*p)` constitue la libération usuelle du pointeur alloué.
L’appel `malloc(sizeof(int))` libère une zone devenue inutile.

L’instruction `int* p = malloc(sizeof(int))` réserve une zone pour un entier. · L’appel `free(p)` libère la zone mémoire précédemment allouée. · La valeur de l’entier alloué peut être manipulée avec l’expression `*p`.

Explication

L’allocation dynamique d’un entier utilise `malloc(sizeof(int))`, puis l’entier est accessible par `*p`. La mémoire obtenue doit être libérée avec `free(p)` ; `malloc` réserve la mémoire et ne la libère pas.

19. À propos de la valeur `NULL` d’un pointeur :

Le déréférencement `*p` reste valide lorsque `p == NULL`.
`NULL` indique qu’aucune zone mémoire valide n’est désignée.
L’expression `*p` est interdite lorsque `p == NULL`.
Un pointeur `NULL` désigne une zone mémoire prête à recevoir un entier.
Le test `p == NULL` permet de détecter l’absence d’une adresse valide.

`NULL` indique qu’aucune zone mémoire valide n’est désignée. · L’expression `*p` est interdite lorsque `p == NULL`. · Le test `p == NULL` permet de détecter l’absence d’une adresse valide.

Explication

Un pointeur égal à `NULL` ne désigne aucune zone mémoire valide et ne peut donc pas être déréférencé. En revanche, un pointeur non nul peut être déréférencé lorsqu’il désigne une adresse valide.

20. Concernant la réservation et l’indexation de tableaux dynamiques :

À partir de l’indice `p`, la ligne se retrouve par i=p%mi = p \% m.
Un tableau de `n` entiers peut être réservé par `malloc(sizeof(int) * n)`.
À partir de l’indice `p`, la colonne se retrouve par j=p/mj = p / m.
Pour un tableau 2D à `m` colonnes, l’indice linéarisé de `(i,j)` vaut p=mi+jp = mi + j.
Dans ce tableau, l’expression `*t` désigne le même élément que `t[0]`.

Un tableau de `n` entiers peut être réservé par `malloc(sizeof(int) * n)`. · Pour un tableau 2D à `m` colonnes, l’indice linéarisé de `(i,j)` vaut $$p = mi + j$$. · Dans ce tableau, l’expression `*t` désigne le même élément que `t[0]`.

Explication

Un tableau dynamique de `n` entiers se réserve avec `malloc(sizeof(int) * n)`, et le premier élément est accessible par `t[0]` ou `*t`. Les coordonnées d’un tableau 2D linéarisé se calculent avec le nombre de colonnes `m`.

21. Concernant la définition d’une structure en langage C :

`struct personne` peut désigner un type de structure regroupant des informations.
Les champs d’une structure peuvent avoir des types différents.
Une structure sert à regrouper plusieurs fonctions sous un type commun.
Une structure rassemble nécessairement des données appartenant au même type.
Une structure regroupe plusieurs données sous un type commun.

`struct personne` peut désigner un type de structure regroupant des informations. · Les champs d’une structure peuvent avoir des types différents. · Une structure regroupe plusieurs données sous un type commun.

Explication

Une structure rassemble plusieurs données, éventuellement de types différents, sous un même type comme `struct personne`. Elle permet ainsi de regrouper des champs hétérogènes dans une même entité.

Révisez avec les flashcards

Mémorisez les réponses avec 59 flashcards sur Programmation en C.

Qu'est-ce que la fonction main en C ?

Le point de départ obligatoire d’un programme C.

Que fait la compilation d'un fichier .c en C ?

Elle transforme le fichier .c en un exécutable.

Comment lance-t-on un exécutable compilé en C ?

Avec la commande ./programme.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Programmation en C.

Voir la fiche →

Cours similaires

Typologie des réseaux informatiques

Réseaux

Présentation assistée par ordinateur

Protocole TCP et IP

Bases de l’architecture informatique

Bases de l’architecture informatique

Alignement stratégique des systèmes d’information

Crée tes propres QCM

Importe ton cours et l'IA génère des QCM avec corrections en 30 secondes.

Générateur de QCM