Salta al contenuto
Note per Studenti Esercizio - Quiz su record di attivazione, new[], dangling pointer e struct (terzo appello 2022-23, quiz)

Esercizio - Quiz su record di attivazione, new[], dangling pointer e struct (terzo appello 2022-23, quiz)

Esame

Quiz del terzo appello del corso di Laboratorio di Programmazione, Ing. Informatica UniPD, a.a. 2022-23 (90 minuti): dieci domande a quattro affermazioni vero/falso (giusta +1+1, sbagliata −0.25-0.25, non data 00). Gli altri esercizi dell'appello: Esercizio - Array stile C, vector e la classe MyArray (terzo appello 2022-23, teoria), Esercizio - Scope e durata della memorizzazione (terzo appello 2022-23, teoria), Esercizio - RAII e garanzie sulle eccezioni (terzo appello 2022-23, teoria), Esercizio - Copiare da array a array dinamico senza delete (terzo appello 2022-23, programmazione).

1) Il record di attivazione di una funzione:

affermazione V/F motivo
È una struttura dati che viene creata a seguito di una chiamata a funzione V
È una struttura dati che viene impilata nel Free Store F nello stack
Ne può esistere una sola copia per ciascun processo F ne esiste uno per ogni chiamata attiva (ricorsione: tanti RA della stessa funzione)
Ha una dimensione che dipende dall'implementazione della relativa funzione V numero e tipo di parametri e variabili locali. Vedi C++ - chiamate a funzione e layout della memoriauna chiamata a funzione crea un record di attivazione (RA) con una copia dei parametri e le variabili locali, impilato nello stack (LIFO) e tolto all'uscita; la dimensione dipende dalle variabili locali e il tempo per inserirlo è costante; il processo ha cinque regioni di memoria: text (istruzioni, spesso read-only), initialized data (globali e statiche inizializzate), uninitialized data o BSS (globali e statiche non inizializzate, azzerate dal sistema), stack (RA) e heap (allocazione dinamica con new e delete); la durata (storage duration) di una variabile è diversa dallo scope: le globali e le static sono statiche (esistono per tutto il programma, inizializzate una volta), le locali sono automatiche (create all'entrata nel blocco, distrutte in ordine inverso all'uscita); le globali sono inizializzate prima del main ma l'ordine fra file diversi non è definito.C++ - chiamate a funzione e layout della memoria →

2) L'allocazione student_list = new students[size]:

affermazione V/F motivo
Per effettuare la deallocazione si utilizza l'istruzione delete[] students; F students è il tipo: si cancella il puntatore, delete[] student_list;
Provoca una chiamata al sistema operativo V l'allocazione dinamica passa dal sistema operativo (costo non trascurabile)
Se size è troppo grande, può causare un overflow nello stack F la memoria è nell'heap, non nello stack: semmai new fallisce (std::bad_alloc)
Se ne deduce che student_list è un oggetto std::list<student> F è un puntatore a students (new T[n] restituisce T*). Vedi C++ - allocazione dinamica della memoria con new e deletela memoria dinamica si prende dal free store (heap) con new, che restituisce un puntatore all'oggetto o al primo elemento dell'array (new T, new T[n], con inizializzatori {}), e si restituisce con delete (per new) e delete[] (per new[]); il puntatore non sa quanti elementi ci sono, la memoria non ha nome e non ha controllo dei limiti; in C++ non c'è garbage collector (scelta per efficienza e controllo), quindi un'area che perde ogni riferimento diventa garbage e produce un memory leak, e gli errori tipici sono la doppia cancellazione e il dangling pointer (si mette il puntatore a nullptr dopo delete); il distruttore ~T() è chiamato dal compilatore quando l'oggetto esce dallo scope o con delete e libera le risorse, per cui una classe come vector acquisisce la memoria nel costruttore e la rilascia nel distruttore; new alloca e chiama il costruttore, delete chiama il distruttore e libera; operator[] con due versioni (T& e const) dà accesso in lettura e scrittura al buffer; si alloca dinamicamente solo se serve davvero (memoria grande, dimensione nota a run-time, durata controllata).C++ - allocazione dinamica della memoria con new e delete →

3) Il problema del dangling pointer:

affermazione V/F motivo
Può essere causato da un errore in fase di deallocazione V dopo una delete il puntatore resta con il vecchio valore, non più valido (o si restituisce l'indirizzo di una locale)
Causa un errore di compilazione F è un errore a run-time
Può causare il lancio di un'eccezione F l'uso di un puntatore pendente è comportamento indefinito (spesso un crash), non un'eccezione C++
Si verifica solo in una chiamata a funzione F ovunque si usi un puntatore dopo delete o un oggetto fuori scope

4) int a = 100, b = 200; int *p = &a, *q = &b; p = q;

affermazione V/F motivo
b è assegnato ad a F p = q copia gli indirizzi, non cambia a
p punta a b V
&a e &b sono uguali F sono due variabili diverse
È stato creato garbage F a è una variabile con nome, ancora raggiungibile: il garbage è memoria dinamica che perde ogni riferimento. Vedi C++ - puntatori, array e castun puntatore è una variabile che contiene un indirizzo di memoria e sa il tipo dell'oggetto puntato (T*); si ottiene l'indirizzo con & e si accede al dato con * (dereference, un lvalue), nullptr indica nessun oggetto e due puntatori a tipi diversi sono tipi diversi; void* è un puntatore a memoria grezza (accetta qualsiasi puntatore ma non si dereferenzia) e i cast (static_cast, reinterpret_cast, const_cast) servono per interfacciarsi con hardware e codice non modificabile; il puntatore, a differenza della reference, si può spostare, può essere nullptr e va dereferenziato, e assegnarlo copia l'indirizzo (shallow copy) mentre assegnare una reference copia l'oggetto; un array C è una sequenza contigua di elementi dello stesso tipo, con dimensione costante, senza controllo dei limiti, che passato a una funzione decade in un puntatore al primo elemento; l'aritmetica dei puntatori somma o sottrae interi spostando di n elementi (non di n byte) e la differenza fra puntatori è in elementi; gli errori classici sono nullptr, puntatori non inizializzati, accessi fuori dai limiti e puntatori a oggetti usciti dallo scope.C++ - puntatori, array e cast →

5) Gli iteratori begin e end di un container STL:

affermazione V/F motivo
Possono essere uguali, ovvero begin() == end() può essere true V container vuoto
begin punta al primo elemento, end all'ultimo elemento F end è dopo l'ultimo
Sono definiti anche se è possibile indicizzare il container con l'operatore [] V tutti i container STL li hanno, vector compreso
Sono definiti solo se esiste almeno un elemento nel container F sono definiti sempre. Vedi STL - sequenze, iteratori e container (vector, list, string)La STL (Standard Template Library) fornisce contenitori (vector, list, map, ...) e algoritmi generici (sort, find, accumulate, ...) tenuti insieme da una interfaccia unificata: la sequenza, un intervallo [begin, end) di elementi gestito tramite iteratori (oggetti che identificano un elemento: * dereferenzia, ++ avanza, == e != confrontano; end è il primo elemento dopo l'ultimo, quindi una sequenza vuota ha begin == end). Gli algoritmi conoscono solo gli iteratori e i contenitori espongono solo iteratori, così i due mondi sono disaccoppiati e cambiare contenitore non cambia l'algoritmo. Un iteratore di lista è una classe annidata con un puntatore al nodo; auto deduce il tipo dell'iteratore. vector (contiguo, [] e at(), insert/erase costosi e che invalidano gli iteratori), string (un vector di char con + e +=), list (nodi concatenati, insert/erase senza spostare gli altri elementi, niente []) e char[] (array C: dimensione fissa, niente iteratori, == confronta i puntatori) a confronto.STL - sequenze, iteratori e container (vector, list, string) →

6) La conversione di una variabile da float a double:

affermazione V/F motivo
È una conversione sicura V double ha più capacità: valore preservato
È una conversione non sicura F
È una conversione non sicura solo su architetture ARM F indipendente dall'architettura
È una conversione sicura solo su architetture a 64 bit F idem. Vedi C++ - tipi, variabili, espressioni e dichiarazioniun tipo definisce contenuto, intervallo di valori e operazioni; un oggetto è una regione di memoria con un tipo, il valore è la configurazione di bit letta in base al tipo, una variabile è un oggetto con un nome; inizializzazione (dare il primo valore) e assegnamento (cambiare il valore) sono diversi; le conversioni verso un tipo più capiente sono sicure, quelle verso un tipo meno capiente (narrowing, double->int, int->char) non lo sono e il compilatore le segnala di rado, ma la notazione con graffe {} le vieta; un'espressione calcola un valore da operandi e operatori, un lvalue è ciò che può stare a sinistra di =, constexpr vuole un valore noto in compilazione mentre const solo un valore che non cambia; gli operatori con side effect (++, --, +=) non vanno mischiati con altri usi della stessa variabile nella stessa espressione perché l'ordine di valutazione non è definito; una dichiarazione introduce un nome e un tipo, una definizione fornisce anche l'entità (memoria per una variabile, corpo per una funzione).C++ - tipi, variabili, espressioni e dichiarazioni →

7) Il distruttore di una classe in C++:

affermazione V/F motivo
Se non ridefinito dall'utente, di default libera il Free Store utilizzato dalla classe F quello generato non libera la memoria puntata da puntatori nudi; distrugge solo i membri
Viene chiamato unicamente quando si usa l'operatore delete F anche all'uscita dallo scope
Se non definito dall'utente, viene implementato automaticamente dal compilatore V
Può avere degli argomenti definiti dall'utente F nessun parametro: ~T(). Vedi C++ - allocazione dinamica della memoria con new e deletela memoria dinamica si prende dal free store (heap) con new, che restituisce un puntatore all'oggetto o al primo elemento dell'array (new T, new T[n], con inizializzatori {}), e si restituisce con delete (per new) e delete[] (per new[]); il puntatore non sa quanti elementi ci sono, la memoria non ha nome e non ha controllo dei limiti; in C++ non c'è garbage collector (scelta per efficienza e controllo), quindi un'area che perde ogni riferimento diventa garbage e produce un memory leak, e gli errori tipici sono la doppia cancellazione e il dangling pointer (si mette il puntatore a nullptr dopo delete); il distruttore ~T() è chiamato dal compilatore quando l'oggetto esce dallo scope o con delete e libera le risorse, per cui una classe come vector acquisisce la memoria nel costruttore e la rilascia nel distruttore; new alloca e chiama il costruttore, delete chiama il distruttore e libera; operator[] con due versioni (T& e const) dà accesso in lettura e scrittura al buffer; si alloca dinamicamente solo se serve davvero (memoria grande, dimensione nota a run-time, durata controllata).C++ - allocazione dinamica della memoria con new e delete →

8) La compilazione di un progetto C++:

affermazione V/F motivo
Il compilatore può ottimizzare il codice in autonomia V purché il comportamento resti lo stesso (-O2)
Un errore di linking si può verificare quando una parte del software esterna al progetto (ad esempio una libreria) è mancante V undefined reference
I commenti presenti nel codice vengono tradotti in linguaggio macchina F spariscono nella compilazione
Il compilatore gcc/g++ di default segnala le conversioni non valide fra tipi diversi V le conversioni non valide (per esempio int →\to string) sono errori; quelle valide ma non sicure (narrowing) non lo sono, se non con {}. Vedi C++ - introduzione, compilazione e linkingC++ è un linguaggio compilato e standard che dà controllo totale sulla macchina (basso livello) e strumenti di astrazione (alto livello); un programma parte da main, usa gli stream (std::cout << ...) e le direttive del preprocessore (#include); il passaggio da sorgente a eseguibile ha tre fasi, preprocessore (espande #include e macro), compilatore (controlla sintassi e tipi e produce un file oggetto in codice macchina) e linker (unisce i file oggetto e le librerie risolvendo i nomi); gli errori di sintassi e di tipo sono del compilatore, i simboli dichiarati ma non definiti (undefined reference) sono del linker; si compila da riga di comando con g++ -o eseguibile sorgente.cpp -lLibreria.C++ - introduzione, compilazione e linking →

9) Un'enumerazione:

affermazione V/F motivo
È equivalente a una classe, ma tutti i membri sono pubblici F non ha membri né funzioni
Crea uno scope se è definita come enum class V
Rende più efficiente l'esecuzione del programma F
Può essere usata per rendere il codice più espressivo V Vedi C++ - enumerazioni e overloading degli operatoriun'enumerazione è un tipo definito dall'utente che specifica un insieme di valori simbolici (enumeratori); enum class crea uno scope (Month::jan), non si converte implicitamente in int, e i valori partono da 0 o dal valore del precedente più uno; l'overloading degli operatori permette di definire gli operatori esistenti per tipi definiti dall'utente (almeno un operando UDT, stesso numero di operandi e stessa sintassi) scrivendo una funzione di nome operator+, operator++, operator[], ...; si può fare con una helper function (due argomenti per un operatore binario, il primo può essere di qualunque tipo) o con una funzione membro (un argomento in meno, perché il primo operando è l'oggetto, quindi l'UDT deve stare a sinistra: T + int sì, int + T no); << e >> sono helper function che prendono e restituiscono ostream& e istream&; ++ ha due forme (pre e post, quest'ultima con un int fittizio); gli operatori più utili sono =, ==, !=, <, [], ().C++ - enumerazioni e overloading degli operatori →

10) In C++, una struct:

affermazione V/F motivo
Deve per forza avere almeno un dato membro e una funzione membro F può essere vuota
Di default ha tutti i suoi dati membro privati F pubblici: è la differenza con class
Non può avere l'implementazione di una classe annidata nel suo corpo F le classi annidate sono lecite
Una volta istanziata permette l'accesso ai dati membri solamente tramite l'operatore -> F . per gli oggetti, -> per i puntatori. Vedi C++ - classi, membri e invariantiuna classe è un tipo definito dal programmatore che rappresenta un concetto con una rappresentazione (dati membro) e delle operazioni (funzioni membro); l'interfaccia pubblica separa chi usa la classe da chi la implementa e i dati privati sono modificabili solo tramite l'interfaccia; struct è una class con membri pubblici di default; l'invariante è la regola che definisce gli stati validi, e il costruttore deve stabilirlo e ogni funzione membro conservarlo; il costruttore (stesso nome della classe) inizializza con una lista di inizializzazione e, se i dati non sono validi, lancia un'eccezione, l'unico modo per far fallire un costruttore; le funzioni membro si definiscono fuori dalla classe (solo le brevissime dentro, dove sono inline); le funzioni che non modificano l'oggetto sono dichiarate const; le funzioni che si possono scrivere con la sola interfaccia pubblica (operator==, next_sunday) sono helper function esterne, spesso nello stesso namespace.C++ - classi, membri e invarianti →

Versione ripasso

Teoria collegata