QCM : Constructeurs et fonctions membres en C++ (32 questions)

Questions et réponses du QCM

1. Dans un programme, une structure `Livre` contient les champs `titre` et `annee`. Une procédure externe `afficherLivre` reçoit une variable de type `Livre` en paramètre pour les manipuler. Quelle organisation cela illustre-t-il ?

Les champs et la procédure sont des membres de la structure
Les champs sont dans la structure et la procédure est définie à l’extérieur
La procédure est dans la structure et les champs sont externes
Les champs sont des paramètres et la procédure est une donnée membre

Les champs sont dans la structure et la procédure est définie à l’extérieur

Explication

Dans une structure, les champs sont déclarés dans la structure, tandis que les fonctions ou procédures qui les manipulent sont externes et reçoivent la structure en paramètre. Intégrer la procédure aux membres confond ce fonctionnement avec celui d’une classe; placer les champs à l’extérieur inverse leur organisation; traiter les champs comme des paramètres confond données et arguments.

2. Quelle caractéristique définit une classe par rapport à une structure ?

Elle désigne une variable créée à partir d’un type défini ailleurs
Elle réunit des variables issues d’un type sans définir de fonctions membres
Elle réunit des données membres et des fonctions membres qui manipulent ces données
Elle réunit des fonctions externes et des paramètres associés à des données

Elle réunit des données membres et des fonctions membres qui manipulent ces données

Explication

Une classe étend le principe d’une structure en réunissant des données membres et des fonctions membres qui manipulent ces données. Un regroupement de champs seul omet les fonctions membres; des fonctions externes décrivent plutôt le modèle de la structure; une variable issue du type est un objet, pas la classe elle-même.

3. Dans une classe `Compte`, `solde` est une variable typée et `deposer` est une procédure qui modifie ce solde. Comment classer ces deux membres ?

`solde` est un paramètre et `deposer` une donnée membre
`solde` est une fonction membre et `deposer` une donnée membre
`solde` est une donnée membre et `deposer` une fonction membre
`solde` est une donnée externe et `deposer` une procédure externe

`solde` est une donnée membre et `deposer` une fonction membre

Explication

Une donnée membre est une variable typée de la classe, tandis qu’une fonction membre est une fonction ou procédure qui manipule ces données. Inverser les rôles confond données et comportement; qualifier `deposer` de donnée confond procédure et variable; placer les deux éléments à l’extérieur ne correspond pas à leur appartenance à la classe.

4. Un programme extérieur à une classe tente de lire un membre déclaré `public` et d’appeler un membre déclaré `private`. Quelle opération est autorisée ?

Appeler les deux membres, car ils appartiennent à la classe
Appeler le membre `private`, mais pas lire le membre `public`
Lire le membre `public`, mais pas appeler le membre `private`
Lire les deux membres, mais ne pouvoir en modifier aucun

Lire le membre `public`, mais pas appeler le membre `private`

Explication

Un membre public peut être manipulé depuis l’extérieur de la classe, alors qu’un membre privé ne le peut pas. L’inversion des deux niveaux d’accès constitue la confusion centrale; interdire tout accès ignore la portée de `public`; autoriser les deux ignore la protection de `private`.

5. Dans une fonction C++, que crée la déclaration `Date uneDate;` et où cette instance est-elle stockée ?

Une instance de `Date` stockée sur la pile
Une fonction qui renvoie une instance de `Date`
Une instance de `Date` stockée sur le tas
Un pointeur vers `Date` stocké sur la pile

Une instance de `Date` stockée sur la pile

Explication

Une déclaration locale telle que `Date uneDate;` crée une instance de `Date` sur la pile. Le tas correspond à une allocation dynamique, tandis qu’un pointeur ou une fonction ne décrit pas l’objet créé par cette déclaration.

6. Un programme crée une instance isolée avec `Date* p = new Date;`. Quelle instruction libère correctement cette instance ?

`delete[] p;`
`delete p;`
`free(p);`
`new Date;`

`delete p;`

Explication

Une instance isolée créée avec `new` se libère avec `delete`. `delete[]` est associé à un tableau créé avec `new[]`, tandis que `new` crée une allocation et que `free` n’est pas l’opérateur correspondant à cette allocation C++.

7. À quel moment un constructeur est-il appelé automatiquement et quelle est sa fonction générale ?

À la destruction d’une instance, généralement pour la terminer
À chaque appel d’une méthode, généralement pour la calculer
À la libération de mémoire, généralement pour la désallouer
À la création d’une instance, généralement pour l’initialiser

À la création d’une instance, généralement pour l’initialiser

Explication

Le constructeur est appelé automatiquement lors de la création d’une instance et peut exécuter des instructions, généralement d’initialisation. L’appel à la destruction relève du destructeur; une méthode ordinaire est appelée par le programme.

8. Une instance locale de `Date` arrive à la fin de sa portée. Quel événement se produit alors pour son destructeur ?

Il alloue automatiquement une nouvelle instance sur le tas
Il est appelé automatiquement pour exécuter éventuellement des instructions de terminaison
Il est appelé automatiquement pour initialiser les membres de l’instance
Il doit être invoqué manuellement avant la fin de la portée

Il est appelé automatiquement pour exécuter éventuellement des instructions de terminaison

Explication

Lorsqu’une instance est détruite, son destructeur est appelé automatiquement et peut exécuter des instructions de terminaison. L’initialisation appartient au constructeur; la fin de portée ne requiert pas d’appel manuel au destructeur.

9. Une classe C++ possède déjà un destructeur. Quelle déclaration supplémentaire respecte les règles relatives aux destructeurs de cette classe ?

Aucune autre déclaration de destructeur, car la classe n’en a qu’un et il est sans paramètre
Un second destructeur avec un paramètre de type entier
Un second destructeur sans paramètre, mais avec un nom différent
Un destructeur surchargé avec un paramètre de type `Date`

Aucune autre déclaration de destructeur, car la classe n’en a qu’un et il est sans paramètre

Explication

Une classe ne peut avoir qu’un seul destructeur, et celui-ci ne prend aucun paramètre. La surcharge de constructeurs ne permet pas de multiplier les destructeurs ni de leur ajouter des paramètres.

10. Dans un programme, on écrit `Date uneDate();` en C++. Quelle interprétation de cette déclaration est correcte ?

Elle crée une instance de `Date` sans paramètre
Elle déclare une fonction sans paramètre qui renvoie une instance de `Date`
Elle appelle une fonction qui renvoie une instance de `Date`
Elle déclare un pointeur sans paramètre vers une instance de `Date`

Elle déclare une fonction sans paramètre qui renvoie une instance de `Date`

Explication

La syntaxe `Date uneDate();` est interprétée comme la déclaration d’une fonction sans paramètre qui renvoie `Date`, et non comme la création d’un objet. La confusion vient de l’apparence d’un appel de constructeur sans argument.

11. Deux objets ont un membre pointeur `p` qui désigne un entier. Après une copie par défaut du premier objet dans le second, que se passe-t-il pour `p` et pour l’entier désigné ?

Le pointeur du nouvel objet est nul, tandis que l’entier reste inchangé.
Les deux pointeurs contiennent la même adresse, sans copier l’entier désigné.
Les pointeurs contiennent la même adresse, et l’entier est copié séparément.
Les pointeurs contiennent des adresses différentes, et l’entier est copié.

Les deux pointeurs contiennent la même adresse, sans copier l’entier désigné.

Explication

La copie par défaut recopie les membres, y compris l’adresse stockée dans le pointeur, mais ne duplique pas l’objet pointé. Des adresses différentes supposent une nouvelle allocation, tandis que la copie séparée de l’entier confond copie de pointeur et copie profonde.

12. Pour définir un constructeur par copie qui reçoit l’objet à copier, quel type de paramètre faut-il déclarer ?

Une référence vers un objet de la même classe.
Un pointeur vers un objet de la même classe.
Aucun paramètre, car la copie est implicite.
Un objet de la même classe passé par valeur.

Une référence vers un objet de la même classe.

Explication

Le constructeur par copie spécifié par le programmeur reçoit l’objet à copier par référence. Un pointeur ou un passage par valeur ne correspond pas à cette signature, et un constructeur sans paramètre ne reçoit pas l’objet source.

13. Un constructeur de `Dossier` contient une liste d’initialisation qui initialise un membre objet `calendrier` avec des arguments. Quand cette initialisation a-t-elle lieu, et quel avantage permet-elle ?

Avant le corps, mais en appelant uniquement un constructeur sans paramètre.
Avant le corps, en appelant un constructeur à paramètres de `calendrier`.
Dans le corps, en affectant à `calendrier` un objet déjà construit.
Après le corps, en appelant un constructeur à paramètres de `calendrier`.

Avant le corps, en appelant un constructeur à paramètres de `calendrier`.

Explication

La liste d’initialisation construit les membres avant l’exécution du corps et permet notamment d’appeler un constructeur à paramètres pour un membre objet. Une affectation dans le corps intervient après la construction des membres, et la liste n’impose pas un constructeur sans paramètre.

14. Une méthode doit renvoyer l’adresse de l’instance qu’elle manipule. Quel élément de C++ permet de récupérer cette adresse ?

La référence `const`.
Le type de retour `void`.
Le pointeur `this`.
Le paramètre `jour`.

Le pointeur `this`.

Explication

Dans une fonction membre, `this` est le pointeur vers l’objet manipulé et peut notamment servir à en renvoyer l’adresse. Un paramètre désigne une donnée reçue, tandis que `const` concerne les modifications permises et `void` l’absence de valeur de retour.

15. Une méthode membre est déclarée avec `const` et tente d’affecter une nouvelle valeur à une donnée membre. Quel résultat faut-il attendre ?

La modification est effectuée lors de l’exécution.
La modification est autorisée si la méthode ne renvoie rien.
La modification est refusée lors de la compilation.
La modification est reportée jusqu’à la destruction de l’objet.

La modification est refusée lors de la compilation.

Explication

Une fonction membre déclarée `const` ne peut pas modifier les données membres, et cette contrainte est vérifiée à la compilation. Le type de retour ne lève pas cette interdiction, et la vérification n’est pas reportée à l’exécution.

16. Une fonction membre reçoit trois paramètres et le deuxième possède une valeur par défaut. Quelle organisation de l’en-tête respecte la règle sur les paramètres par défaut ?

Donner aussi une valeur par défaut au troisième paramètre.
Laisser le troisième paramètre obligatoire après le deuxième.
Donner une valeur par défaut au premier paramètre seulement.
Déplacer le paramètre par défaut après le corps de la fonction.

Donner aussi une valeur par défaut au troisième paramètre.

Explication

Les paramètres ayant une valeur par défaut doivent être les derniers paramètres de l’en-tête : si le deuxième en a une, le troisième doit aussi en avoir une. Laisser le troisième obligatoire placerait un paramètre sans valeur par défaut après un paramètre qui en possède une.

17. Une classe propose trois méthodes `estAnterieur`, prenant respectivement une référence vers une date, un pointeur vers une date et un nombre de jours. Quel mécanisme permet de conserver le même nom pour ces méthodes ?

La surcharge, grâce à des types de retour différents
La surcharge, grâce à des paramètres différents
L’utilisation d’une méthode unique avec des paramètres facultatifs
La redéfinition, grâce à des types de retour différents

La surcharge, grâce à des paramètres différents

Explication

La surcharge permet de définir plusieurs fonctions membres de même nom et de même type de retour, à condition que leurs paramètres diffèrent. La redéfinition avec un même profil et la différenciation par le seul type de retour confondent les critères de surcharge; les paramètres facultatifs ne constituent pas ici le mécanisme décrit.

18. Un programmeur souhaite donner un sens à l’opérateur `+` entre deux objets d’une classe qu’il a créée. Quel mécanisme C++ peut-il employer ?

La surcharge des opérateurs pour cette classe
La redéfinition des opérateurs pour toutes les classes
La conversion automatique de la classe en type primitif
La surcharge des seules fonctions membres ordinaires

La surcharge des opérateurs pour cette classe

Explication

En C++, la plupart des opérateurs peuvent être redéfinis pour une classe : cette redéfinition est la surcharge des opérateurs. Une conversion de type ou une surcharge de fonction ordinaire est un autre mécanisme, et cette définition ne modifie pas toutes les classes.

19. Dans une classe `Date`, l’opérateur `<` est une fonction membre appelée ainsi : `dateA < dateB`. Dans cette surcharge membre, quel rôle joue chaque objet ?

`dateA` est à gauche et `dateB` à droite
`dateA` et `dateB` sont deux paramètres explicites
`dateB` est à gauche et `dateA` à droite
`dateA` est un paramètre global et `dateB` l’objet appelant

`dateA` est à gauche et `dateB` à droite

Explication

Dans une surcharge membre, l’objet qui appelle l’opérateur constitue l’opérande gauche, et l’objet passé en paramètre constitue l’opérande droite. Inverser leur rôle ou traiter l’opérateur comme une fonction globale ne correspond pas à ce fonctionnement.

20. Pour comparer deux dates avec `<`, on compare d’abord leurs années. Elles sont égales, leurs mois sont aussi égaux, mais le jour de la première date est supérieur à celui de la seconde. Quel résultat doit produire la comparaison ?

Vrai, car le jour de la première date est plus grand
Vrai, car les années des deux dates sont égales
Faux, car les mois des deux dates sont égaux
Faux, car le jour de la première date est plus grand

Faux, car le jour de la première date est plus grand

Explication

La comparaison examine les années, puis les mois en cas d’égalité, puis les jours si les mois sont également égaux; ici, un jour supérieur signifie que la première date n’est pas antérieure. Conclure sur l’égalité des années ou des mois omet l’étape suivante, tandis que déclarer la comparaison vraie inverse le sens des jours.

21. Une expression `std::cout << date` doit afficher une valeur `Date`. Pourquoi l’opérateur `<<` est-il défini comme fonction globale amie plutôt que comme méthode membre de `Date` ?

La date et le flux sont tous deux des objets appelants
La date est l’opérande gauche et le flux est passé en paramètre
L’amitié transforme une méthode membre en fonction globale
Le flux est l’opérande gauche et la date est passée en paramètre

Le flux est l’opérande gauche et la date est passée en paramètre

Explication

Dans `std::cout << date`, l’opérateur s’applique d’abord au flux, et la date à afficher est reçue comme paramètre; il est donc défini comme fonction globale amie de `Date`. Prendre la date pour opérande gauche ou placer le flux après elle méconnaît la forme de l’expression; l’amitié ne convertit pas une méthode membre en fonction globale.

22. Deux objets `Date` sont additionnés avec un opérateur `+` dont le comportement est défini pour cette classe. Que contient l’objet résultat ?

Les sommes avec report entre jours, mois et années
Les sommes séparées, enregistrées dans la première date opérande
La somme des jours et les mois et années de la première date
Les sommes séparées des jours, des mois et des années

Les sommes séparées des jours, des mois et des années

Explication

L’opérateur `+` additionne séparément les jours, les mois et les années, puis retourne une copie du résultat dans un nouvel objet. Ne sommer qu’un champ, modifier une opérande ou effectuer des reports entre composantes ne suit pas le comportement défini.

23. Deux objets `Date` existent déjà. On exécute ensuite `Date date2 = date1;` pour créer un objet, puis `date4 = date1;` pour mettre à jour un objet existant. Quels mécanismes sont appelés, dans cet ordre ?

L’opérateur d’affectation, puis le constructeur par copie
L’opérateur d’affectation, puis l’opérateur d’affectation
Le constructeur par copie, puis le constructeur par copie
Le constructeur par copie, puis l’opérateur d’affectation

Le constructeur par copie, puis l’opérateur d’affectation

Explication

L’initialisation `Date date2 = date1` construit un nouvel objet avec le constructeur par copie, tandis que `date4 = date1` affecte la valeur à un objet déjà créé. Confondre ces contextes inverse les mécanismes ou attribue à tort le même mécanisme aux deux opérations.

24. L’opérateur `[]` d’une classe `Date` renvoie une référence au jour pour l’indice `0`, au mois pour `1` et à l’année pour `2`. Quel champ est renvoyé pour l’indice `7` ?

Le mois
Aucun champ
Le jour
L’année

Le jour

Explication

Pour tout indice autre que `0`, `1` ou `2`, l’opérateur renvoie une référence au jour. L’indice `7` ne correspond donc ni au mois ni à l’année, et le cas par défaut ne renvoie pas une absence de référence.

25. Dans un programme de planification, les durées prévues pour trois travaux pratiques sont représentées par des objets `Date` utilisés comme décalages. Quelle opération permet de vérifier si le temps total nécessaire tient avant la fin du semestre ?

Additionner les trois durées à la date de fin, puis comparer le résultat à la date de début
Additionner les trois durées entre elles, puis comparer le total directement à la date de début
Comparer chaque durée à la date de fin, puis retenir la durée la plus longue
Additionner les trois durées, puis ajouter ce total à la date de début et comparer le résultat à la date de fin

Additionner les trois durées, puis ajouter ce total à la date de début et comparer le résultat à la date de fin

Explication

L’opérateur `+` combine les durées, puis ajoute le décalage total à la date de début afin de comparer la date prévue à la fin du semestre. Comparer les durées séparément omet leur cumul, ajouter le cumul à la date de fin inverse le point de départ, et comparer le total à la date de début ne calcule pas la date prévue.

26. Dans un message d’échec, un programme affiche une date prévue puis la date de fin au moyen d’expressions enchaînées avec `<<`. Quel comportement doit avoir l’opérateur `<<` surchargé pour une date ?

Lire une date depuis le flux et retourner cette date
Afficher la date dans le flux et retourner ce flux
Retourner la date affichée et interrompre l’enchaînement
Afficher la date sans retourner le flux

Afficher la date dans le flux et retourner ce flux

Explication

L’opérateur `<<` écrit la date dans le flux et retourne ce flux, ce qui permet d’enchaîner l’affichage de plusieurs éléments. Retourner la date confond le résultat avec le flux, omettre le retour empêche l’enchaînement et lire une date correspond à une opération d’entrée.

27. Une fonction crée un objet ordinaire sur la pile et se termine sans transférer cet objet ailleurs. Que devient l’objet lorsqu’il n’est plus visible ?

Il demeure en mémoire après le retour de la fonction
Il est libéré par delete parce qu’il se trouve sur la pile
Il est libéré comme une variable ordinaire devenue invisible
Il reste alloué jusqu’à un appel explicite à delete

Il est libéré comme une variable ordinaire devenue invisible

Explication

Un objet créé sur la pile est libéré lorsqu’il n’est plus visible, comme une variable ordinaire. Exiger `delete` confond cet objet avec une allocation sur le tas, tandis que le maintien après la fin de la fonction méconnaît sa durée de vie.

28. Un pointeur `Date*` reçoit l’adresse d’un objet créé avec `new`. Après avoir utilisé cet objet, quelle séquence assure sa libération manuelle et marque le pointeur comme nul ?

Affecter `nullptr` au pointeur, puis appliquer `delete`
Appliquer `delete[]` au pointeur, puis lui affecter `nullptr`
Laisser la portée se terminer, puis compter sur la libération automatique
Appliquer `delete` au pointeur, puis lui affecter `nullptr`

Appliquer `delete` au pointeur, puis lui affecter `nullptr`

Explication

Un objet `Date` créé avec `new` sur le tas se libère avec `delete`, après quoi le pointeur peut être mis à `nullptr`. `delete[]` convient à un tableau alloué dynamiquement, et remplacer l’adresse par `nullptr` avant `delete` fait perdre le pointeur vers l’objet à libérer.

29. Une fonction reçoit un objet par recopie dans un cas et par référence dans un autre. Quelle différence décrit correctement ces deux modes ?

La recopie crée une copie locale, tandis que la référence utilise l’objet d’origine.
La recopie utilise l’objet d’origine, tandis que la référence crée une copie locale.
Les deux modes créent une copie locale, mais seule la référence conserve son adresse.
Les deux modes utilisent l’objet d’origine, mais la recopie interdit de le modifier.

La recopie crée une copie locale, tandis que la référence utilise l’objet d’origine.

Explication

Le passage par recopie crée un objet local distinct, alors que le passage par référence donne accès à l’objet d’origine. L’inversion recopie/référence inverse les mécanismes, la confusion entre référence et autorisation de modification mélange deux propriétés distinctes, et la copie temporaire attribuée à la référence est incorrecte.

30. Une fonction reçoit une date avec le paramètre `Date& d` et doit modifier l’objet fourni afin que l’appelant récupère cette modification. Quel rôle joue ce paramètre ?

Il donne accès à la date d’origine pour la lire, sans pouvoir la modifier.
Il donne accès à une copie locale et laisse la date d’origine inchangée.
Il crée un pointeur vers une nouvelle date que la fonction doit retourner.
Il donne accès à la date d’origine et permet de la modifier comme donnée-résultat.

Il donne accès à la date d’origine et permet de la modifier comme donnée-résultat.

Explication

Un paramètre `Date&` référence l’objet fourni et permet à la fonction de le modifier comme donnée-résultat. Une référence constante interdit la modification, la copie locale ne transmet pas les changements à l’objet initial, et un pointeur à retourner n’est pas impliqué par ce type de paramètre.

31. Dans une méthode appelée avec `date1.egal(date2)`, comment le compilateur traduit-il l’accès direct de la méthode à un membre de `date1` ?

Il ajoute `date1` comme dernier paramètre et conserve l’accès direct au membre.
Il ajoute un pointeur sur `date1` comme premier paramètre et utilise `this->membre`.
Il ajoute un pointeur sur `date2` comme premier paramètre et utilise `this->membre`.
Il n’ajoute aucun paramètre et transforme l’accès en `date2->membre`.

Il ajoute un pointeur sur `date1` comme premier paramètre et utilise `this->membre`.

Explication

L’appel d’une fonction membre ajoute automatiquement un pointeur sur l’objet appelant comme premier paramètre, et les accès directs à ses membres deviennent des accès via `this->membre`. Le pointeur concerne l’argument plutôt que l’appelant dans la confusion sur `date2`; le placer en dernier ou supprimer la transformation méconnaît le mécanisme.

32. Lors de l’appel `date1.egal(date2)`, quel objet est l’appelant et sous quelle forme `date2` est-il transmis à la méthode ?

`date1` est l’appelant et `date2` est transmis par référence constante.
`date2` est l’appelant et `date1` est transmis par référence constante.
`date1` est l’appelant et `date2` est transmis par valeur.
`date1` est l’appelant et `date2` est transmis comme pointeur constant.

`date1` est l’appelant et `date2` est transmis par référence constante.

Explication

Dans l’expression `date1.egal(date2)`, `date1` est l’objet sur lequel la méthode est appelée, tandis que `date2` est fourni sous forme de référence constante. L’inversion des rôles désigne le mauvais appelant, la transmission par valeur crée une copie, et un pointeur constant n’est pas le type de paramètre indiqué.

Révisez avec les flashcards

Mémorisez les réponses avec 80 flashcards sur Constructeurs et fonctions membres en C++.

Où sont définis les champs d’une structure ?

Dans la structure.

Où sont définies les fonctions et procédures qui manipulent une structure ?

À l’extérieur de la structure.

Que reçoivent en paramètre les fonctions et procédures manipulant une structure ?

La structure.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Constructeurs et fonctions membres en C++.

Voir la fiche →

Cours similaires

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