Problème 1
Étudiez le programme suivant, puis répondez aux questions ci-dessous. Nous aimerions que vous répondiez aux questions en examinant uniquement le code source. En d'autres termes, ne le copiez pas dans un fichier, le compilez et répondez aux questions sur la base de son exécution. Ça va te faire plaisir !
int main() {
int counter, first, last, next;
first = 1; last = 2;
for (counter = first; counter <= last; counter++) {
cout << "\n " << counter;
next = counter * counter;
cout << " " << next;
}
counter = first;
while (counter <= last) {
cout << "\n " << counter;
next = counter * counter;
cout << " " << next;
counter++;
}
counter = first;
do {
cout << "\n " << counter;
next = counter * counter;
cout << " " << next;
counter++;
} while (counter < last);
}
Question 1: Quel est le résultat de ce programme ?
| A) |
1 2 2 1 2 2 1 2 2.4 |
| B) |
1 2 1 2 1 2 |
| C) |
1 2 1 2 1 |
| D) |
1 2 1 1 2 |
| E) | Il ne renvoie rien. Il existe des erreurs de syntaxe. |
Question 2: Que se passerait-il si nous supprimions l'initialisation de "counter" ? avant la boucle répétitive ?
| A) | Boucle infinie : la boucle "do-while" génère une série de 1. |
| B) | La sortie du programme ne changera pas |
| C) | La boucle de bouclage génère les valeurs 2 et 4. |
| D) | La boucle ne renvoie rien |
| E) | La boucle de bouclage génère les valeurs 3 et 9. |
Question 3: Compte tenu du programme d'origine mentionné en haut de cette page, supposons que nous avons supprimé la ligne qui initialise la variable compteur avant la boucle "while" Quoi se produirait si nous supprimions également la ligne counter++ à l'intérieur de la boucle "while-loop", comme dans les éléments suivants ?
| A) | La boucle "al" ne génère rien. |
| B) | La boucle "while" génère les valeurs 1 et 1. la boucle de do-while ne génère rien. |
| C) | Le résultat de la boucle "while" est identique à celui obtenu lorsque les deux lignes sont inclus. |
| D) | Le système produira des nombres aléatoires jusqu’à ce que nous activions l’ordinateur désactivée. |
| E) | La boucle "al" est une boucle infinie. |
Question 4: Compte tenu du programme d'origine mentionné en haut de cette page, que se passerait-il si la boucle "while" ressemblait à ceci ?
counter = first;
while (counter <= last) {
cout << "\n" << counter;
if (first % 2 == 0)
next = counter * counter;
cout << " " << next;
counter++;
}| A) | La sortie de la boucle "while" est identique à celle du programme d'origine. |
| B) | La boucle "while" n'a aucun résultat. |
| C) | La sortie de la boucle "while" est 1 1 et 1 4. |
| D) | La sortie de la boucle "while" est 1 2 et 2 4. |
| E) | La sortie de la boucle "while" est 1 4 et 2 4. |
| F) | La sortie de la boucle "while" est 2 4 et 2 4. |
Question 5: Que se passerait-il si la première variable était supérieure à la dernière ?
| A) | La boucle "alors" produit quelque chose, mais rien d'autre ne l'est. |
| B) | La boucle "faire" en boucle génère quelque chose, mais rien d'autre ne le fait. |
| C) | Il n'y aura aucun résultat. |
| D) | Le programme générera une erreur ou un plantage |
| E) | La boucle for va générer quelque chose, mais rien d'autre ne le sera. |
Question 6: Quel sera le résultat du programme si la première variable est initialisée pour qu'elle soit identique à la dernière variable ?
| A) | La boucle "faire" en boucle génère quelque chose, mais rien d'autre ne le fait. |
| B) | La boucle "alors" produit quelque chose, mais rien d'autre ne l'est. |
| C) | Chaque boucle génère une ligne. |
| D) | La commande "dowhile-loop" génère deux lignes et l'autre boucle une ligne. |
| E) | Elle ne renvoie rien |
| F) | La boucle for va générer quelque chose, mais rien d'autre ne le sera. |
Ensemble de problèmes 2
Comme pour l'ensemble de problèmes précédent, voici un programme que vous pouvez examiner. Veuillez répondre aux questions qui suivent en vous concentrant uniquement sur le code source.
#include <iostream>
using namespace std;
int main() {
int Boys = 3, Girls = 5;
void F1(int males, int females);
void F2(int &m, int &f);
F1(Boys, Girls);
cout << "\nAfter calling F1, within main()";
cout << "\n\tBoys = " << Boys; // #2
cout << "\n\tGirls = " << Girls;
F2(Boys, Girls);
cout << "\nAfter calling F2, within main()";
cout << "\n\tBoys = " << Boys; // #4
cout << "\n\tGirls = " << Girls;
}
void F1(int b, int g) {
b += 3, g += 4;
cout << "\nF1";
cout << "\n\tBoys = " << b; // #1
cout << "\n\tGirls = " << g;
}
void F2(int &b, int &g) {
b = b + 8, g = g + 5;
cout << "\nF2";
cout << "\n\tBoys = " << b; // #3
cout << "\n\tGirls = " << g;
}Question 1: Quel est le résultat de la variable Boys sur les lignes marquées ?
| A) |
N° 1: 6 N° 2: 3 N° 3: 11 N° 4: 11 |
| B) |
N° 1: 6 N° 2: 3 N° 3: 11 N° 4: 3 |
| C) |
N° 1: 6 N° 2: 6 N° 3: 11 N° 4: 11 |
| D) | Elle ne génère rien, car elle n'est ni compilée, ni exécutée. |
Question 2: Sélectionnez toutes les réponses applicables concernant les lignes suivantes du programme:
void F1(int males, int females); void F2(int &m, int &f);
| A) | Les règles C++ stipulent que nous pouvons supprimer ces deux lignes tant que les méthodes sont définies avant utilisation. |
| B) | Les règles C++ stipulent que les noms d'arguments doivent être identiques entre la déclaration et la définition. |
| C) | Ce programme plantera si nous supprimons ces deux lignes. |
| D) | Il est plus courant que les déclarations soient indiquées dans le le champ d'application. |
| E) | Celles-ci sont appelées déclarations de transfert. |
Question 3: Si nous déplaçons la ligne suivante de "main()" et la plaçons dans le que va-t-il se passer ?
int Boys = 3, Girls = 5;
| A) | La sortie serait la même. |
| B) | Le nombre de garçons = 3 et les filles = 5 dans tous les résultats. |
| C) | Le nombre de garçons égal à 3 et celui de filles = 5 uniquement dans la sortie de main() |
Question 4: Et si nous modifions le début du programme pour qu'il se présente comme suit:
// We have moved moved these to global scope
const int Boys = 3;
const int Girls = 5;
void main() {
//int Boys = 3, Girls = 5;| A) | Le programme se compile, mais se bloque lorsque nous essayons de l’exécuter. |
| B) | La sortie ne change pas |
| C) | La sortie est la suivante : Garçons = 3 filles = 5 tout au long du programme. |
| D) | La sortie serait Boys = 3 Girls = 5 uniquement dans la sortie de main(). |
| E) | Il est probable que le programme ne se compile pas (en fonction du compilateur). |
Question 5: Les données sont transmises par la valeur définie dans F2.
| A) | Vrai |
| B) | Faux |
Ensemble de problèmes 3
Comme pour l'ensemble de problèmes précédent, voici un programme que vous pouvez examiner. Veuillez répondre aux questions qui suivent en ne s'intéresse qu'au code source.Celui-ci est plus intéressant que les deux précédents - tracer le code avec soin.
#include <iostream>
using namespace std;
const int MAX_SIZE = 20;
typedef int ARR2D[MAX_SIZE][MAX_SIZE];
void Print(ARR2D in_array, int rows, int cols);
void Fill(ARR2D in_array, int rows, int cols);
int main() {
ARR2D matrix;
int row, col;
do {
cout << "Please enter the size of the matrix to generate (rows and cols) :" << endl;
cin >> row >> col;
} while (row <= 0 || row > MAX_SIZE || col <= 0 || col > MAX_SIZE);
Fill(matrix, row, col);
Print(matrix, row, col);
return(0);
}
void Print(ARR2D in_array, int rows, int cols) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
cout << '\t' << in_array[i][j];
cout << endl;
}
}
void Fill(ARR2D in_array, int rows, int cols) {
for(int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++)
in_array[i][j] = 0;
const int limit = rows * cols;
int cNum = 1;
int cRow = 0;
int cCol = 0;
int cDir = 0; // 0-north, 1-east, 2-south, 3-west
while(true) {
// Place the number.
in_array[cRow][cCol] = cNum;
cNum++;
if (cNum > limit) break;
int fRow = cRow;
int fCol = cCol;
while (true) {
fRow = cRow;
fCol = cCol;
switch(cDir) {
case 0: fRow--; break;
case 1: fCol++; break;
case 2: fRow++; break;
case 3: fCol--; break;
}
if ( fRow >= 0 && fRow < rows && fCol >= 0 && fCol < cols && in_array[fRow][fCol] == 0)
break;
cDir = (cDir + 1) % 4;
}
cRow = fRow;
cCol = fCol;
}
}Question 1: Que renvoie ce programme avec une entrée de 3 pour les lignes et de 4 pour de colonnes ?
| A) |
1 2 3 4 5 6 7, 8, 9 10 11 12 |
| B) |
1 2 3 4 5 6 7 8 9 10 11 12 |
| C) |
12 11 10 9 8 7 6 5 4, 3, 2, 1 |
| D) |
1 3 2 4 8 6 7 5 9 11 10 12 |
| E) |
1 2 3 4 10 11 12 5 9 8 7 6 |
| G) |
9 8 7 6 10 11 12 5 1 2 3 4 |
| H) | Il ne renvoie rien : la logique est défectueuse. |
| I | Il ne renvoie rien en raison d'erreurs de syntaxe. |
| J) | Il ne renvoie rien, ce qui n'est pas censé le faire. |
| K) | Il génère les 12 premiers chiffres qui vous viennent à l'esprit pendant que vous attendez l'exécution du programme. |
Question 2: Et si nous ajoutions la ligne suivante à notre fonction main() ?
MAX_SIZE = 10;
| A) | Cela n'est pas autorisé en C++. |
| B) | C'est autorisé. le programme s'exécuterait avec MAX_SIZE défini sur 20 |
| C) | C'est autorisé. le programme s'exécuterait avec MAX_SIZE défini sur 10. |
Question 3: Examinez les quatre lignes suivantes du programme ci-dessus:
const int MAX_SIZE = 20; typedef int ARR2D [MAX_SIZE][MAX_SIZE]; void Print (ARR2D A, int rows, int cols); void Fill (ARR2D A, int rows, int cols);
1) Est-il possible d'utiliser un const dans un typedef ?
2) Est-il possible d'utiliser un typedef dans une déclaration avant qu'une variable de ce type ne soit déclarée ?
| A) | 1) Oui 2) Oui |
| B) | 1) Non 2) Non |
| C) | 1) Non 2) Oui |
| D) | 1) Oui 2) Non |
Question 4: Pouvons-nous utiliser les éléments suivants:
#define MAX_SIZE 20
const int MAX_SIZE = 20;
| A) | Oui, cela fonctionne et vous pouvez utiliser #define pour les constantes dans C++ |
| B) | Oui, cela fonctionnera, mais nous n'utilisons généralement pas #define pour les constantes. en C++ |
| C) | #define n'est pas disponible en C++ |
| D) | Vous ne pouvez pas faire l'une de ces choses en C |
Question 5: typedef est utilisé pour créer un alias pour un nom de type.
| A) | Vrai |
| B) | Faux |
Question 6: Que se passerait-il si nous n'initialisions pas le tableau sur 0 dans le Fill() ?
| A) | Elle s'exécutera, mais les résultats seront tous des 12 |
| B) | Il fonctionnera correctement et générera le même résultat que si le tableau était initialisé sur 0 |
| C) | Le programme ne s'exécutera pas ou plantera |
| D) | Il s'exécutera, mais la sortie sera uniquement des 0 |
| E) | Elle s'exécutera, mais ne générera peut-être aucun résultat. |
Question 7: Cochez toutes les réponses applicables. Pourquoi utilisons-nous const pour MAX_SIZE dans ce programme ? N'est-il pas plus facile de taper « 20 » au lieu de MAX_SIZE, où qu'elle se trouve avez-vous besoin ?
| A) | MAX_SIZE est une valeur C++ intégrée que tout le monde peut utiliser. Ça vient d'être défini et de l'utiliser. |
| B) | Les constantes globales doivent être évitées, tout comme les variables globales |
| C) | L'utilisation d'un const rend notre programme plus facile à comprendre |
| D) | Les chiffres magiques d'un programme sont généralement considérés comme une bonne pratique. |
| E) | Si nous voulons changer MAX_SIZE, il suffit de le changer dans une seule lieu |
Question 8: L'instruction switch de la fonction Fill() devrait avoir une valeur par défaut car il est considéré comme un bon style d'en inclure un.
| A) | Vrai |
| B) | Faux |
Question 9: Notez que dans la fonction Fill(), nous déclarons des variables entre les instructions. Par exemple, cNum et cRow sont déclarés et initialisés après l'exécution d'une boucle for. Cela fonctionnera-t-il en C++, ou toutes les variables doivent-elles être déclarées en haut de la fonction ?
| A) | Ce n'est pas un problème. |
| B) | Toutes les variables doivent être déclarées en haut de la fonction. |
| C) | Les deux manières sont incorrectes - C++ n’autorise pas les variables n’importe où dans un programme. |
| D) | Toutes les variables doivent être déclarées dans le champ d'application global. |
Ensemble de problèmes 4
Voici un ensemble de fichiers définissant et testant une classe simple. Comme d'habitude, répondez aux questions qui suivent en vous référant uniquement au code source.
Voici le fichier d'en-tête (cow.h):
#ifndef COW_H
#define COW_H
using namespace std;
typedef enum Color {black, brown, beige, blackandwhite, nocolor};
class Cow {
public:
Cow();
~Cow();
// accessors
double weight() { return weight_; };
string name() { return name_; };
Color color() { return color_; };
// mutators
void set_name(string inName) { name_ = inName; };
void set_color(Color inColor) { color_ = inColor; };
void set_weight(double inWeight) {weight_ = inWeight; };
void Moo();
void Properties();
private:
Color color_;
double weight_;
string name_;
};
#endifVoici le fichier .cc associé (cow.cc):
#include <iostream>
#include "cow.h"
using namespace std;
Cow::Cow() {}
Cow::~Cow() {}
void Cow::Moo() {
cout << name() << " says MOO." << endl;
}
void Cow::Properties() {
cout << name() << " weighs " << weight() << ", is "
<< color() << " and says MOO." << endl;
}Et voici un programme client pour cette classe (cowmain.cc):
#include <iostream>
#include "cow.h"
using namespace std;
int main() {
Cow cow1;
cow1.set_name("betsy");
cow1.set_weight(400.0);
cow1.set_color(black);
cow1.Moo();
cow1.Properties();
}Question 1: Que génère ce programme ?
| A) | Betsy dit MOO. Betsy pèse 400, est à 0 et dit MOO. |
| B) | Betsy dit MOO. Betsy pèse 400 personnes, est noire et dit MOO. |
| C) | Betsy dit MOO. Betsy pèse 400, est |
Question 2: Nous ne devons jamais placer le code des méthodes d'accesseur et de mutateur dans un fichier d'en-tête. Notez qu'un accesseur est une méthode qui renvoie une valeur et un mutateur. est une méthode qui modifie une valeur.)
| A) | Vrai |
| B) | Faux |
Question 3: Avons-nous besoin du mot clé "Vache::" avant chacune des définitions de fonction dans cow.cc ?
| A) | Non - car cow.h est inclus |
| B) | Oui |
Question 4 : Quel rôle occupez-vous ?
#ifndef COW_H #define COW_H ... #endif
dans le fichier d'en-tête ?
Sélectionnez toutes les réponses qui s'appliquent.
| A) | Ils ne servent à rien car le nom du fichier est cow.h et non COW_H. |
| B) | Sans cela, nous obtiendrions une erreur d'exécution |
| C) | Si nous ne le faisons pas, nous risquons d'inclure le fichier plusieurs fois. |
| D) | Il n'a aucun effet, car un ou plusieurs mots clés sont mal orthographiés. |
| E) | Ils ne font rien car la classe Cow n’a qu’un seul fichier d’en-tête. |
Question 5: Que se passerait-il si nous ajoutions la ligne suivante à cowmain.cc ?
cow1.weight_ = 24;
| A) | Le programme s'exécuterait et la variable de poids serait modifiée par cette ligne. |
| B) | Le programme se compile et s'exécute, mais plante sur cette ligne. |
| C) | C++ ne le permet pas. |
| D) | Le programme est compilé et exécuté, mais la variable de pondération n'est pas modifié par cette ligne. |
Question 6: Lorsque la ligne suivante est exécutée, le constructeur de la classe Cow est appelé:
Cow cow1;
Quelles sont les caractéristiques importantes des constructeurs ?
Plusieurs réponses sont possibles.
| A) | Ils ne renvoient généralement aucune valeur |
| B) | Si nous ne fournissons pas de constructeur dans notre classe, celle-ci non compilé |
| C) | Le constructeur de la classe Cow est atypique puisqu'il n'initialise pas les variables privées. |
| D) | Ils portent toujours le même nom que la classe. |
| E) | Une classe peut comporter plusieurs constructeurs, à condition que les arguments différent |
| F) | Un constructeur est appelé lorsqu'une classe est instanciée. |
Question 7: Quelles sont les principales caractéristiques d'un destructeur ?
| A) | Un destructeur est appelé lorsqu'un objet sort du champ d'application |
| B) | Un destructeur porte le même nom que la classe, mais est précédé du signe "~" |
| C) | Il y a un problème dans le destructeur de cow.cc, ne fait rien. |
| D) | Si vous ne créez pas de destructeur pour votre classe, celle-ci compiler |
Question 8: Compte tenu de la façon dont le programme client utilise la classe, suivantes:
La division des membres en public et en privé dans la classe Vache n'est pas appropriée. Autrement dit, quelque chose de privé devrait être public ou quelque chose de public devrait être privé.
| A) | Vrai |
| B) | Faux |
Question 9: Que se passe-t-il si nous ajoutons un autre constructeur en plus de celui nous devons utiliser cow.cc. Le nouveau constructeur ressemble à ceci
Cow::Cow(string inName, double inWeight, Color inColor) {
set_name(inName);
set_weight(inWeight);
set_color(inColor);
}Et nous ajoutons les lignes suivantes à main():
Cow cow2("milly", 350.2, brown);
cow2.Moo();
cow2.Properties();aux clients ?
Plusieurs réponses sont possibles.
| A) | La ligne dans main() où nous initialisons cow2 plantera. |
| B) | Nous ne pouvons avoir qu'un seul constructeur. |
| C) | C'est courant en C++ |
| D) | Oui, mais il ne s'agit pas d'une utilisation standard de C++ |
| E) | L'exécution fonctionne, mais elle n'affiche aucun résultat, car les objets privés ne sont pas initialisés. |
| F) | Nous ne pouvons pas appeler setName(), setColor() et setWeight() depuis une méthode de la même classe. |
Questions bonus
Question 1) Quel est le résultat de l'appel ci-dessous ?
#include <iostream>
using namespace std;
void HelpMe(int *p, int *num, int *q);
void WhereAmI(int *p, int *q, int a);
void HelpMe(int *p, int *num, int *q) {
int a;
a = 2;
q = &a;
*p = *q + *num;
num = p;
}
void WhereAmI(int *p, int *q, int a) {
a = 6;
*p = a + *p;
*q = a + 3;
HelpMe(q, &a, p);
}
int main() {
int *p;
int q;
int *num;
int a;
a = 3;
q = 5;
p = &a;
num = &q;
HelpMe(&a, p, num);
WhereAmI(&q, p, *num);
cout << "*p = " << *p << " q = " << q << " *num = " << *num << endl;
}
Question 2) Considérons l'instruction suivante, en supposant qu'une classe Apple existe et a été initialisée. La classe Apple comporte une variable d'instance color_ :
Apple* granny_smith = new Apple;
Parmi les affirmations suivantes, sélectionnez celle qui est vraie:
| A) | Apple* granny_smith = NULL; if (granny_smith == NULL)... Ce n'est PAS normal - NULL n'est pas une valeur qui peut être vérifiée de cette manière. |
| B) | Pomme* granny_smith, fuji; Cela déclare deux pointeurs vers des objets Apple |
| C) | La variable granny_smith contient les valeurs des variables d'instance associées à un objet Apple |
| D) | Apple* granny_smith = NULL; Ce n’est pas grave, |
| E) | La variable granny_smith contient l'adresse d'un objet Apple |
| F) | string gs_color = *(granny_smith.get_color(||) Cette instruction renvoie la couleur de l'objet granny_smith, en supposant qu'il a été initialisé. |
| G) | L'espace de stockage du nouvel objet Apple est alloué dans le tas de mémoire |
| H) | L'espace de stockage du nouvel objet Apple est alloué sur la pile d'exécution |
| I | int* a = &b; Cela place l'adresse de "b" dans "a". |
Question 3) Quel est le résultat du programme suivant ?
#include <iostream>
using namespace std;
const int kNumVeggies = 4;
void Grill(int squash, int *mushroom);
int Saute(int onions[], int celery);
void Grill(int squash, int *mushroom) {
*mushroom = squash/4;
cout << *mushroom + squash << endl;
}
int Saute(int onions[], int celery) {
celery *= 2;
onions[celery]++;
Grill(onions[0], &onions[3]);
cout << celery << " " << onions[3] << endl;
return celery;
}
int main() {
int broccoli, peppers[kNumVeggies], *zucchini;
for (broccoli = 0; broccoli < kNumVeggies; broccoli++)
peppers[broccoli] = kNumVeggies - broccoli;
zucchini = &peppers[Saute(peppers,1)];
Grill(*zucchini, zucchini);
zucchini--;
cout << peppers[3] + *zucchini + *(zucchini + 1) << endl;
}
Réponses au quiz
Vous devez essayer de répondre à toutes les questions ci-dessus sans regarder les réponses. Il est préférable de demander de l'aide à quelqu'un plutôt que de passer directement à la feuille de réponses pour obtenir de l'aide.
Vous pouvez consulter les réponses aux problèmes ci-dessus sur cette page.