QCM sur les Tableaux en Langage C

Les tableaux en langage C sont une structure de données fondamentale permettant de stocker une collection d’éléments de même type. Comprendre et manipuler les tableaux est essentiel pour tout programmeur en C. Cet article propose un QCM détaillé sur les tableaux en C, accompagné d’explications et de corrigés pour chaque question.

QCM

Question 1 : Déclaration et initialisation des tableaux

Quelle est la syntaxe correcte pour déclarer et initialiser un tableau de 5 entiers en C ?

A. int arr[5] = {1, 2, 3, 4, 5};
B. int arr = {1, 2, 3, 4, 5};
C. int arr[5] = (1, 2, 3, 4, 5);
D. int arr[5]; arr = {1, 2, 3, 4, 5};

Réponse : A

Explication : La syntaxe correcte pour déclarer et initialiser un tableau de 5 entiers en C est int arr[5] = {1, 2, 3, 4, 5};. Les autres options sont incorrectes car elles utilisent une syntaxe non valide.

Question 2 : Accès aux éléments du tableau

Comment accéder au troisième élément d’un tableau arr en C ?

A. arr[2]
B. arr[3]
C. arr[4]
D. arr(3)

Réponse : A

Explication : En C, les indices des tableaux commencent à 0. Ainsi, le troisième élément du tableau arr est accessible via arr[2].

Question 3 : Taille des tableaux

Quelle est la taille en mémoire d’un tableau int arr[10] si un entier occupe 4 octets ?

A. 10 octets
B. 20 octets
C. 30 octets
D. 40 octets

Réponse : D

Explication : La taille totale en mémoire d’un tableau est égale au nombre d’éléments multiplié par la taille de chaque élément. Ici, 10 * 4 = 40 octets.

Question 4 : Boucles et tableaux

Quel est le résultat de ce programme en C ?

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int sum = 0;
    for(int i = 0; i < 5; i++) {
        sum += arr[i];
    }
    printf("%d\n", sum);
    return 0;
}

A. 10
B. 11
C. 12
D. 15

Réponse : D

Explication : Le programme additionne tous les éléments du tableau arr. La somme est 1 + 2 + 3 + 4 + 5 = 15.

Question 5 : Tableaux multidimensionnels

Comment déclare-t-on un tableau bidimensionnel de 3 lignes et 4 colonnes en C ?

A. int arr[3, 4];
B. int arr[3][4];
C. int arr[4][3];
D. int arr[12];

Réponse : B

Explication : La déclaration correcte d’un tableau bidimensionnel en C est int arr[3][4];, où 3 représente le nombre de lignes et 4 le nombre de colonnes.

Question 6 : Passage de tableaux aux fonctions

Quelle est la manière correcte de passer un tableau à une fonction en C ?

A. void func(int arr);
B. void func(int *arr);
C. void func(int arr[]);
D. B et C

Réponse : D

Explication : En C, un tableau peut être passé à une fonction en utilisant un pointeur ou en utilisant la syntaxe d’un tableau. Les deux déclarations void func(int *arr); et void func(int arr[]); sont correctes.

Question 7 : Index hors limites

Quel est le comportement si l’on accède à un index hors des limites du tableau en C ?

A. Le programme plante immédiatement.
B. Une erreur de compilation se produit.
C. Un comportement indéfini se produit.
D. Le programme retourne -1.

Réponse : C

Explication : Accéder à un index hors des limites d’un tableau en C entraîne un comportement indéfini. Cela peut provoquer des erreurs d’exécution, des résultats incorrects ou même ne provoquer aucun problème apparent.

Question 8 : Initialisation partielle

Que contient le tableau après cette déclaration en C : int arr[5] = {1, 2}; ?

A. {1, 2, 0, 0, 0}
B. {1, 2, 2, 2, 2}
C. {1, 2, 1, 2, 1}
D. {1, 2, garbage, garbage, garbage}

Réponse : A

Explication : Lorsqu’un tableau est partiellement initialisé en C, les éléments non initialisés sont automatiquement mis à zéro.

QCM Avancé sur les Tableaux en Langage C

Les tableaux en C offrent des possibilités avancées pour la gestion de données. Ils peuvent être utilisés dans des contextes variés et complexes, notamment en algorithmes, structures de données et gestion de mémoire. Ce QCM avancé explore des aspects plus complexes et des cas particuliers liés aux tableaux en C, avec des corrigés détaillés.

QCM

Question 1 : Tableaux dynamiques

Comment allouer dynamiquement un tableau de 10 entiers en C ?

A. int *arr = malloc(10 * sizeof(int));
B. int arr[10] = malloc(10 * sizeof(int));
C. int *arr = malloc(10);
D. int *arr = alloc(10 * sizeof(int));

Réponse : A

Explication : La fonction malloc alloue de la mémoire dynamique. La syntaxe correcte pour allouer un tableau de 10 entiers est int *arr = malloc(10 * sizeof(int));.

Question 2 : Tableaux et pointeurs

Quel est le résultat de ce programme en C ?

#include <stdio.h>

void update(int *arr, int size) {
    for(int i = 0; i < size; i++) {
        arr[i] += 10;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    update(arr, size);
    for(int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

A. 11 12 13 14 15
B. 1 2 3 4 5
C. 10 20 30 40 50
D. Compilation error

Réponse : A

Explication : La fonction update incrémente chaque élément du tableau de 10. Le résultat imprimé est donc 11 12 13 14 15.

Question 3 : Tableaux multidimensionnels et mémoire

Quel est l’avantage d’utiliser des tableaux à une dimension (linéarisés) par rapport aux tableaux multidimensionnels en termes de gestion de la mémoire en C ?

A. Meilleure lisibilité du code
B. Simplification des calculs d’index
C. Réduction de l’utilisation de la mémoire
D. Amélioration des performances de cache

Réponse : D

Explication : Les tableaux linéarisés améliorent les performances de cache car les éléments sont stockés de manière contiguë en mémoire, ce qui améliore l’accès séquentiel.

Question 4 : Tableaux de structures

Considérez la structure suivante et le code correspondant :

#include <stdio.h>

typedef struct {
    int id;
    char name[20];
} Person;

int main() {
    Person people[2] = {{1, "Alice"}, {2, "Bob"}};
    printf("%s\n", people[1].name);
    return 0;
}

Quel est le résultat de ce programme ?

A. Alice
B. Bob
C. Compilation error
D. Runtime error

Réponse : B

Explication : Le programme initialise un tableau de structures Person et imprime le nom de la deuxième personne, soit “Bob”.

Question 5 : Tableaux et fonctions variadiques

Est-il possible de passer un tableau à une fonction variadique en C ? Pourquoi ?

A. Oui, car les tableaux peuvent être traités comme des pointeurs
B. Non, car les fonctions variadiques ne supportent pas les tableaux
C. Oui, mais avec des limitations
D. Non, car le standard C l’interdit

Réponse : C

Explication : Il est possible de passer un tableau à une fonction variadique, mais le programmeur doit gérer manuellement la taille du tableau et les pointeurs, car les fonctions variadiques ne possèdent pas de mécanisme intégré pour identifier la fin d’un tableau.

Question 6 : Accès via pointeurs et tableaux

Quel est le résultat de ce programme ?

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;
    *(ptr + 3) = 100;
    printf("%d\n", arr[3]);
    return 0;
}

A. 30
B. 40
C. 100
D. Compilation error

Réponse : C

Explication : Le pointeur ptr est initialisé pour pointer sur le tableau arr. L’instruction *(ptr + 3) = 100; modifie le quatrième élément du tableau à 100. Donc, arr[3] est maintenant 100.

Question 7 : Sous-tableaux

Comment copier un sous-tableau de taille n à partir d’un tableau src en C ?

A. Utiliser la fonction memcpy
B. Utiliser une boucle for
C. Utiliser la fonction strncpy
D. A et B

Réponse : D

Explication : Les deux méthodes sont valides. memcpy est efficace pour copier des blocs de mémoire, tandis qu’une boucle for peut être utilisée pour des copies spécifiques et potentiellement des conversions de type.

Question 8 : Tableaux et optimisation du compilateur

Quel est le rôle des directives restrict dans l’optimisation des accès aux tableaux ?

A. Indiquer au compilateur que les tableaux peuvent se chevaucher
B. Indiquer au compilateur que les tableaux ne se chevauchent pas
C. Empêcher toute optimisation
D. Permettre une allocation dynamique

Réponse : B

Explication : La directive restrict indique au compilateur que les pointeurs n’ont pas de chevauchement dans leur portée, permettant ainsi des optimisations plus agressives par le compilateur.

Conclusion

Les tableaux sont une composante essentielle de la programmation en C. Comprendre leur déclaration, leur manipulation et les pièges courants est crucial pour écrire des programmes efficaces et sans erreurs. Ce QCM couvre les aspects fondamentaux des tableaux en C et offre des explications détaillées pour chaque question, facilitant ainsi l’apprentissage et la révision des concepts clés.