Gruppo di problemi 1
Studia il programma che segue, quindi rispondi alle domande riportate di seguito. Ti invitiamo a rispondere alle domande osservando solo il codice sorgente, ad esempio non copiarlo in un file, compilalo e rispondi alle domande sulla base dell'esecuzione. Così non sarà più divertente!
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);
}
Domanda 1. Qual è l'output di questo programma?
| A) |
1 2 2 4 1 2 2 4 1 2 2 4 |
| B) |
1 1 2 4 1 1 2 4 1 1 2 4 |
| C) |
1 1 2 4 1 1 2 4 1 1 |
| D) |
1 1 2 4 1 1 1 1 2 4 |
| Non restituisce nulla: ci sono errori di sintassi. |
Domanda 2. Cosa succederebbe se rimuoviamo l'inizializzazione di "counter" prima del loop do-while?
| A) | Un loop infinito: il loop do-while restituisce una serie di 1 |
| B) | L'output del programma non cambierà |
| C) | Il loop do-while produce 2 e 4. |
| D) | Il loop do-while non restituisce alcun risultato |
| Il loop do-while produce 3 e 9. |
Domanda 3. Dato il programma originale nella parte superiore di questa pagina, supponiamo di aver rimosso la riga che inizializza la variabile del contatore prima del loop pending. Cosa accadrebbe se rimuoviamo anche la riga contatto++ all'interno del loop keep, come di seguito?
| A) | Il ciclo many non restituisce alcun risultato. |
| B) | Il loop but restituisce 1 e 1, mentre il loop do-while non genera nulla. |
| C) | L'output del loop than è lo stesso di quando sono incluse entrambe le righe. |
| D) | Il sistema produrrà numeri casuali fino allo spegnimento del computer. |
| Il ciclo if è un ciclo infinito |
Domanda 4: considerando il programma originale in alto in questa pagina, cosa accadrebbe se il ciclo keep fosse così?
counter = first;
while (counter <= last) {
cout << "\n" << counter;
if (first % 2 == 0)
next = counter * counter;
cout << " " << next;
counter++;
}
| A) | L'output del loop when è lo stesso del programma originale. |
| B) | Il loop but non produrrà nulla |
| C) | L'output del ciclo why è 1 1 e 1 4. |
| D) | L'output del loop why è 1 2 e 2 4. |
| L'output del loop many è 1 4 e 2 4. | |
| F) | L'output del ciclo many è 2 4 e 2 4. |
Domanda 5. Che cosa succede se la prima variabile è maggiore dell'ultima?
| A) | Il loop mentre produrrà qualcosa, ma nient'altro. |
| B) | Il comando do mentre-loop restituisce qualcosa, ma nient'altro. |
| C) | Non verrà visualizzato alcun output. |
| D) | Il programma genererà un errore o un arresto anomalo del feed |
| Il for-loop restituirà qualcosa, ma nient'altro lo produrrà. |
Domanda 6: quali risultati produrrà il programma se inizializzamo la prima variabile in modo che corrisponda all'ultima variabile?
| A) | Il comando do mentre-loop restituisce qualcosa, ma nient'altro. |
| B) | Il loop mentre produrrà qualcosa, ma nient'altro. |
| C) | Ogni loop restituirà una riga. |
| D) | Il loop do mentre-loop genera 2 righe e l'altro loop una riga. |
| Non produrrà nulla | |
| F) | Il for-loop restituirà qualcosa, ma nient'altro lo produrrà. |
Gruppo di problemi 2
Come per il problema precedente, ecco un programma che ti invitiamo a prendere in considerazione. Rispondi alle domande che seguono esaminando solo il codice sorgente.
#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;
}
Domanda 1. Qual è l'output della variabile Boys sulle linee contrassegnate?
| 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) | Non restituisce nulla perché non esegue la compilazione né l'esecuzione. |
Domanda 2: scegli tutte le risposte pertinenti alle seguenti righe del programma:
void F1(int males, int females); void F2(int &m, int &f);
| A) | Le regole C++ indicano che è possibile rimuovere queste due righe a condizione che i metodi siano definiti prima dell'uso. |
| B) | Le regole C++ indicano che i nomi degli argomenti devono essere gli stessi tra la dichiarazione e la definizione. |
| C) | Se rimuoviamo queste due righe, il programma si arresta in modo anomalo. |
| D) | È più comune che le dichiarazioni siano indicate nell'ambito globale. |
| Questi messaggi sono chiamati dichiarazioni di inoltro. |
Domanda 3: se spostiamo la riga seguente da main() e la inseriamo nell'ambito globale, cosa succederà?
int Boys = 3, Girls = 5;
| A) | L'output sarà lo stesso. |
| B) | I ragazzi = 3 e le ragazze = 5 in tutti gli output |
| C) | Boys = 3 e Girls = 5 solo nell'output da main() |
Domanda 4. Cosa succede se cambiassimo l'inizio del programma in questo modo:
// We have moved moved these to global scope
const int Boys = 3;
const int Girls = 5;
void main() {
//int Boys = 3, Girls = 5;
| A) | Il programma viene compilato, ma si arresta in modo anomalo quando proviamo a eseguirlo. |
| B) | Non ci saranno modifiche all'output |
| C) | L'output sarebbe Boys = 3 Girls = 5 per tutto il programma. |
| D) | L'output sarebbe Boys = 3 Girls = 5 solo nell'output da main() |
| Il programma probabilmente non verrà compilato (a seconda del compilatore). |
Domanda 5: i dati vengono trasmessi in base al valore in F2.
| A) | Vero |
| B) | Falso |
Gruppo di problemi 3
Come per il problema precedente, ecco un programma che ti invitiamo a prendere in considerazione. Rispondi alle domande che seguono osservando solo il codice sorgente.Questa è più interessante delle due precedenti: traccia il codice con attenzione.
#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;
}
}
Domanda 1: cosa produce questo programma con input 3 per le righe e 4 per le colonne?
| 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 |
|
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) | Non genera nulla perché la logica è errata. |
| I) | Non restituisce nulla: sono presenti errori di sintassi. |
| G) | Non restituisce nulla, non dovrebbe. |
| K) | Restituisce i primi 12 numeri che vengono in mente mentre attendi l'esecuzione del programma. |
Domanda 2. E se aggiungessimo la riga seguente alla funzione main()?
MAX_SIZE = 10;
| A) | Questa operazione non è consentita in C++. |
| B) | Questa operazione è consentita. Il programma viene eseguito con un valore impostato di MAX_SIZE su 20 |
| C) | Questa operazione è consentita. Il programma viene eseguito con il valore MAX_SIZE impostato su 10. |
Domanda 3. Considera le quattro righe seguenti del programma precedente:
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) È possibile utilizzare un const in un typedef?
2) È possibile utilizzare un typedef in una dichiarazione prima che sia stata dichiarata una variabile di quel tipo?
| A) | 1) Sì 2) Sì |
| B) | 1) No 2) No |
| C) | 1) No 2) Sì |
| D) | 1) Sì 2) No |
Domanda 4. Possiamo utilizzare quanto segue?
#define MAX_SIZE 20anziché:
const int MAX_SIZE = 20;
| A) | Sì, funzionerà e va bene utilizzare #define per le costanti in C++ |
| B) | Sì, funzionerà, ma in genere non utilizziamo #define per le costanti in C++ |
| C) | #define non è disponibile in C++ |
| D) | Non puoi fare nessuna di queste cose in C |
Domanda 5: typedef viene utilizzato per creare un alias per un nome di tipo.
| A) | Vero |
| B) | Falso |
Domanda 6: cosa succederebbe se non iniziassimo a 0 l'array nella funzione Fill()?
| A) | Verrà eseguito ma l'output sarà |
| B) | Funzionava e genererà lo stesso output, come se l'array fosse inizializzato su 0 |
| C) | Il programma non verrà eseguito o si arresta in modo anomalo |
| D) | Verrà eseguito ma l'output sarà pari a 0 |
| Verrà eseguito, ma potrebbe non generare alcun output |
Domanda 7: seleziona tutte le risposte pertinenti. Perché utilizziamo const per MAX_SIZE in questo programma? Non è più facile digitare "20" invece di MAX_SIZE ovunque sia necessario?
| A) | MAX_SIZE è un valore C++ integrato utilizzabile da chiunque. Devi solo configurarlo e usarlo. |
| B) | Le costruzioni globali dovrebbero essere evitate proprio come le variabili globali |
| C) | L'uso di una const rende il nostro programma più facile da capire |
| D) | I numeri magici in un programma sono generalmente considerati una buona pratica. |
| Se vogliamo modificare MAX_SIZE, dobbiamo farlo solo in un'unica posizione |
Domanda 8: l'istruzione switch nella funzione Fill() deve avere un carattere predefinito di maiuscole e minuscole, poiché è considerato uno stile valido includerne uno.
| A) | Vero |
| B) | Falso |
Domanda 9. Nella funzione Fill(), dichiariamo le variabili tra un'istruzione e l'altra. Ad esempio, cNum e cRow vengono dichiarati e inizializzati dopo l'esecuzione di un ciclo for-loop. Funzionerà in C++ oppure è necessario dichiarare tutte le variabili all'inizio della funzione?
| A) | Questo va bene. |
| B) | Tutte le variabili devono essere dichiarate nella parte superiore della funzione. |
| C) | Entrambi sono errati: C++ non consente variabili in nessun punto di un programma. |
| D) | Tutte le variabili devono essere dichiarate in ambito globale. |
Gruppo di problemi 4
Ecco un insieme di file che definiscono e testano un corso semplice. Come di consueto, rispondi alle domande successive facendo riferimento solo al codice sorgente.
Ecco il file di intestazione (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_;
};
#endif
Ecco il file .cc associato (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;
}
Ed ecco un programma per i clienti di questo corso (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();
}
Domanda 1. Qual è l'output del programma?
| A) | betsy dice: "MOO". betsy pesa 400, è 0 e dice MOO. |
| B) | betsy dice: "MOO". betsy pesa 400, è nera e dice MOO. |
| C) | betsy dice: "MOO". betsy pesa 400, è |
Domanda 2: non dobbiamo mai inserire il codice per i metodi di accesso e modificatore in un file di intestazione. Nota: una funzione di accesso è un metodo che restituisce un valore, mentre un mutatore è un metodo che modifica un valore.
| A) | Vero |
| B) | Falso |
Domanda 3: serve il carattere "Cow::" prima di ogni definizione della funzione in cow.cc?
| A) | No, dato che cow.h è incluso |
| B) | Sì |
Domanda 4. Quale ruolo:
#ifndef COW_H #define COW_H ... #endif
riprodurre nel file di intestazione?
Seleziona tutte le risposte pertinenti:
| A) | Non servono a nulla perché il nome del file è cow.h e non COW_H. |
| B) | Se non lo facessimo, riceveremmo un errore di runtime |
| C) | Se non lo abbiamo fatto, potremmo includere il file più di una volta |
| D) | Non fanno nulla perché una o più parole chiave non sono scritte in modo corretto. |
| Non fanno nulla perché la classe Cow ha un solo file di intestazione. |
Domanda 5. Cosa succederebbe se aggiungessimo la seguente riga a cowmain.cc?
cow1.weight_ = 24;
| A) | Il programma viene eseguito e la variabile peso viene modificata da questa riga. |
| B) | Il programma verrebbe compilato ed eseguito, ma si arrestava in modo anomalo su quella riga. |
| C) | C++ non consente questa operazione. |
| D) | Il programma deve eseguire la compilazione e l'esecuzione, ma la variabile peso non viene modificata da questa riga. |
Domanda 6: quando viene eseguita la riga seguente, viene chiamato il costruttore della classe Cow:
Cow cow1;
Quali sono alcune caratteristiche importanti dei costruttori?
Seleziona tutte le risposte pertinenti
| A) | Di solito non restituiscono valori |
| B) | Se non forniamo un costruttore nella nostra classe, la classe non verrà compilata |
| C) | Il costruttore nella classe Cow è atipico poiché non inizializza le variabili private. |
| D) | Hanno sempre lo stesso nome del corso |
| Una classe può avere più costruttori purché gli argomenti siano diversi | |
| F) | Un costruttore viene richiamato quando viene instanciata una classe. |
Domanda 7. Quali sono alcune importanti caratteristiche di un distruttore?
| A) | Un distruttore viene chiamato quando un oggetto esce dall'ambito |
| B) | Un distruttore ha lo stesso nome della classe, ma è preceduto da "~" |
| C) | C'è qualcosa che non va nel distruttore in cow.cc, che non fa nulla. |
| D) | Se non creiamo un distruttore per la nostra classe, la classe non compilerà |
Domanda 8. Dato il modo in cui il programma client utilizza la classe, considera quanto segue:
La suddivisione dei membri in pubblico e privato nella classe Cow non è appropriata. In altre parole, un elemento di questo tipo dovrebbe essere pubblico oppure un elemento di questo tipo dovrebbe esserlo.
| A) | Vero |
| B) | Falso |
Domanda 9: cosa accadrebbe se aggiungessimo un altro costruttore oltre a quello che dobbiamo per cow.cc? Il nuovo costruttore è simile al seguente:
Cow::Cow(string inName, double inWeight, Color inColor) {
set_name(inName);
set_weight(inWeight);
set_color(inColor);
}
Inoltre, aggiungiamo le seguenti righe a main():
Cow cow2("milly", 350.2, brown);
cow2.Moo();
cow2.Properties();
Possiamo farlo?
Seleziona tutte le risposte pertinenti
| A) | La riga in main() in cui inizializziamo cow2 si arresta in modo anomalo. |
| B) | Possiamo avere un solo costruttore. |
| C) | È comune in C++ |
| D) | Sì, ma non si tratta di un utilizzo tipico di C++ |
| Verrà eseguito correttamente, ma non restituirà nulla perché i privati non sono inizializzati. | |
| F) | Non possiamo chiamare setName(), setColor() e setWeight() dall'interno di un metodo della stessa classe. |
Domande aggiuntive
Domanda 1) Qual è il risultato di quanto segue?
#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;
}
Domanda 2) Considera la seguente istruzione, supponendo che esista una classe Apple e che sia stata inizializzata. La classe Apple ha una variabile di istanza color_:
Apple* granny_smith = new Apple;
Scegli tra le seguenti affermazioni che sono vere:
| A) | Apple* granny_smith = NULL; if (granny_smith == NULL)... NON è consentito. Il valore NULL non è un valore che può essere controllato in questo modo. |
| B) | Apple* granny_smith, fuji; dichiara due puntatori agli oggetti Apple |
| C) | La variabile granny_smith contiene i valori della variabile di istanza associati a un oggetto Apple |
| D) | Apple* granny_smith = NULL; va bene così, |
| La variabile granny_smith contiene l'indirizzo di un oggetto Apple | |
| F) | string gs_color = *(granny_smith.get_color()); Questa istruzione restituisce il colore dell'oggetto granny_smith, supponendo che sia stato inizializzato. |
| G) | Lo spazio di archiviazione per il nuovo oggetto Apple è allocato nell'heap |
| H) | Lo spazio di archiviazione per il nuovo oggetto Apple è allocato sullo stack di runtime |
| I) | int* a = &b; Viene inserito l'indirizzo di b in a. |
Domanda 3) Qual è l'output del seguente programma?
#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;
}
Risposte al quiz
Dovresti provare a rispondere a tutte le domande precedenti senza guardare le risposte. È meglio chiedere aiuto a qualcuno piuttosto che passare direttamente al foglio delle risposte.
Puoi visualizzare le risposte ai problemi precedenti qui.