Deep Copy, Regola del Tre e Overloading degli Operatori
new: la copia superficiale e il double freethis+ e * per i vettorithrowMatrix) sono matrici di Eigen, il cui costruttore di copia e il cui assegnamento fanno già la copia profonda che oggi scriviamo a mano.DenseLayer::forward l’uscita dello strato si calcola con outputs = Wt * (*inputs_ptr);: il * fra due matrici di Eigen è un operatore definito da Eigen, il prodotto righe per colonne.forward controlla che l’ingresso abbia il numero di righe atteso; se no, lancia un’eccezione std::runtime_error con le due dimensioni nel messaggio.this. Il messaggio usa this->Nin, il numero di ingressi dell’oggetto su cui forward è chiamato; il controllo scrive solo Nin, come di solito.Oggi ogni esempio si scrive e si compila durante la lezione, in un progetto CMake come quello dei laboratori, ma in una cartella a parte.
CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(Lezione10)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
# AddressSanitizer (Lezione 08)
add_compile_options(-fsanitize=address -g)
add_link_options(-fsanitize=address)
# qui una riga add_executable per esempioLEZIONE_10, fuori da basic_neural_plusplus, e apritela in VS Code.CMakeLists.txt qui a sinistra.LEZIONE_10:cmake -B build.L’AddressSanitizer mostra gli errori di memoria degli esempi di oggi.
Sopra ogni esempio c’è il nome del suo file. Quando lo incontrate, create il file, copiatevi il codice e aggiungete al CMakeLists.txt la sua riga:
add_executable(copia_superficiale copia_superficiale.cpp)
add_executable(puntatore_this puntatore_this.cpp)
add_executable(tre_membri tre_membri.cpp)
add_executable(vettore_somma vettore_somma.cpp)
add_executable(eccezioni eccezioni.cpp)
add_executable(scalare scalare.cpp Vettore2D.cpp) # esercizio
add_executable(lampo lampo.cpp) # esercizio lampo
add_executable(discesa discesa.cpp Vettore2D.cpp) # esercizioPoi, dalla cartella LEZIONE_10, compilate ed eseguite solo quell’esempio:
cmake -B build rilegge il CMakeLists.txt: senza, --target non trova un esempio appena aggiunto. Con --target si compila solo l’esempio indicato: un esercizio non ancora finito non blocca gli altri. I messaggi citati sono quelli di g++ su Linux; con clang (macOS) il testo cambia, il significato no.
Dalla Lezione 07: se una classe non li dichiara, il compilatore genera il costruttore di copia e l’operatore di assegnamento.
DynamicArray b = a; crea b come copia di a: costruttore di copia.b = a; con b già esistente: operatore di assegnamento.Entrambi copiano membro per membro: ogni attributo di a viene copiato nell’attributo corrispondente di b. Di un puntatore copiano l’indirizzo, non i dati a cui punta; un array dichiarato come attributo, come double v[5];, viene invece copiato elemento per elemento.
Dalla Lezione 09: DynamicArray alloca un array nell’heap nel costruttore e lo libera nel distruttore. La Lezione 09 si chiudeva con un avvertimento: questa classe non si può ancora copiare. Oggi vediamo perché, e come si rimedia.
copia_superficiale.cpp
#include <iostream>
class DynamicArray {
private:
int size_;
double* data_;
public:
DynamicArray(int size)
: size_(size), data_(new double[size]) {}
~DynamicArray() { delete[] data_; }
int size() const { return size_; }
void imposta(int i, double v) { data_[i] = v; }
double leggi(int i) const { return data_[i]; }
};
int main() {
DynamicArray a(5);
a.imposta(0, 1.0);
DynamicArray b = a;
b.imposta(0, 9.0);
std::cout << a.leggi(0) << "\n";
return 0;
}La classe è quella della Lezione 09, senza il controllo sugli indici per brevità.
b è creato con il costruttore di copia generato dal compilatore, che copia size_ e data_.b.9, non 1. Modificando b si è modificato a.a.data_ e b.data_ contengono lo stesso indirizzo: c’è un solo array, e i due oggetti lo condividono.b.data_[0] vuol dire scrivere nell’array di a.Alla fine del main vengono distrutti a e b, in ordine inverso a quello di creazione (Lezione 09):
b: il suo distruttore esegue delete[] sull’indirizzo 0x5600a0, e l’array viene liberato;a: il suo distruttore esegue delete[] sullo stesso indirizzo, che è già stato liberato.Liberare due volte la stessa memoria è il double free della Lezione 08. Il programma si interrompe:
free(): double free detected in tcache 2 e Aborted (Linux), pointer being freed was not allocated (macOS);-fsanitize=address: ERROR: AddressSanitizer: attempting double-free, con la riga del delete[].In copia_superficiale.cpp cambiate la riga 19, DynamicArray b = a;, in DynamicArray b(5);. Cosa stampa il programma? L’errore alla fine c’è ancora?
Stampa 1, senza errori: b ha un array suo. Il problema nasce dalla copia.

Con DynamicArray b(3); e poi b = a; l’operatore di assegnamento generato dal compilatore copia size_ e data_ di a in b.
b.data_ ora contiene l’indirizzo dell’array di a: alla fine c’è di nuovo il double free.b, quello di 3 elementi, non è stato liberato e nessuna variabile ne conosce più l’indirizzo: è un memory leak.Il problema nasce dal distruttore: libera l’array, quindi l’array deve avere un solo proprietario. La copia membro per membro crea due proprietari dello stesso array.
Importante
Regola del Tre: se una classe ha bisogno di uno di questi tre membri, ha bisogno di tutti e tre.
DynamicArray b = a;;b = a; quando b esiste già.Il motivo è sempre lo stesso: la classe possiede una risorsa che il compilatore non sa duplicare. Il costruttore di copia e l’operatore di assegnamento scritti da noi devono fare una copia profonda (deep copy): allocare un nuovo array e copiarvi i valori.
Le due copie di DynamicArray b = a;, una accanto all’altra:
b.data_ riceve l’indirizzo dell’array di a; un solo array per due oggetti.b.data_ riceve l’indirizzo di un array nuovo, in cui si copiano i valori di quello di a. Modificare b non modifica a, e ogni distruttore libera il proprio array: nessun double free, nessun leak.thispuntatore_this.cpp
#include <iostream>
class DynamicArray {
private:
int size_;
double* data_;
public:
DynamicArray(int size)
: size_(size), data_(new double[size]) {}
~DynamicArray() { delete[] data_; }
int size() const { return size_; }
// in più rispetto a copia_superficiale.cpp
void stampaIndirizzo() const {
std::cout << this << "\n";
}
};
int main() {
DynamicArray a(5);
std::cout << &a << "\n";
a.stampaIndirizzo();
return 0;
}In ogni metodo this è un puntatore che contiene l’indirizzo dell’oggetto su cui il metodo è chiamato.
a.stampaIndirizzo(), this vale &a.*this è l’oggetto stesso; this->size_ è l’attributo size_, di solito scritto solo size_ (->: Lezione 06).Nella classe completa (slide seguente) serve all’operator=: this == &altro e return *this.
this in due oggettiIn puntatore_this.cpp, dopo la riga 21, aggiungete:
Cosa stampano le due righe nuove?
Due volte lo stesso indirizzo, diverso da quello di a: in b.stampaIndirizzo(), this vale &b. Il metodo è uno solo, this dipende dall’oggetto su cui lo si chiama.
tre_membri.cpp
#include <iostream>
class DynamicArray {
private:
int size_;
double* data_;
public:
DynamicArray(int size) : size_(size), data_(new double[size]) {}
DynamicArray(const DynamicArray& altro)
: size_(altro.size_), data_(new double[altro.size_]) {
for (int i = 0; i < size_; i++) data_[i] = altro.data_[i];
}
DynamicArray& operator=(const DynamicArray& altro) {
if (this == &altro) return *this;
delete[] data_;
size_ = altro.size_;
data_ = new double[size_];
for (int i = 0; i < size_; i++) data_[i] = altro.data_[i];
return *this;
}
~DynamicArray() { delete[] data_; }
void imposta(int i, double v) { data_[i] = v; }
double leggi(int i) const { return data_[i]; }
};mainStampa 1 9 7: a, b e c hanno tre array distinti.
Compilato con -fsanitize=address, il programma termina senza segnalazioni: nessun double free e nessun leak.
Le prossime slide spiegano il costruttore di copia (righe 9–12) e l’operatore di assegnamento (righe 13–20).
const reference.altro.data_.È l’unico punto in cui il costruttore di copia scritto da noi differisce da quello del compilatore: data_ riceve un indirizzo nuovo.
Con b già creato, b = a; chiama b.operator=(a), non il costruttore di copia: nel metodo this è &b e altro è a.
a = a;): this e &altro coincidono. Senza il controllo, il delete[] libererebbe l’array prima di copiarlo.b va liberato, altrimenti è il leak visto prima.*this: c = b = a; è c = (b = a), e ciò che restituisce b = a diventa l’argomento di c.operator= (con void non compilerebbe). Per reference (Lezione 05), per non fare una copia profonda in più.In tre_membri.cpp togliete un membro alla volta, ricompilate ed eseguite; poi rimettetelo.
9 9 7, poi attempting double-free: senza il nostro costruttore di copia, a e b condividono l’array.7 9 7, poi attempting double-free: c = a; copia l’indirizzo, quindi c scrive nell’array di a, e il vecchio array di c è perso.a = a; dopo la riga 27. Cosa stampa?-1.83255e-06 9 7: il delete[] libera l’array di a, e il nuovo array si riempie copiando da altro, cioè da se stesso, mai inizializzato. Il numero è il valore con cui l’AddressSanitizer riempie la memoria appena allocata.vettore_somma.cpp
#include <iostream>
class Vettore2D {
private:
double x_, y_;
public:
Vettore2D(double x, double y) : x_(x), y_(y) {}
Vettore2D operator+(const Vettore2D& altro) const {
return Vettore2D(x_ + altro.x_, y_ + altro.y_);
}
double getX() const { return x_; }
double getY() const { return y_; }
};
int main() {
Vettore2D v1(1.0, 2.0);
Vettore2D v2(3.0, 4.0);
Vettore2D v3 = v1 + v2;
std::cout << v3.getX() << " " << v3.getY() << "\n";
return 0;
}Riga 8: Vettore2D(...) crea un oggetto senza nome, un temporaneo (Lezione 07), che vive fino alla fine dell’istruzione.
L’operator= è già un esempio di overloading degli operatori: una classe può definire che cosa fanno =, +, -, *, == e quasi tutti gli altri operatori sui suoi oggetti.
operator+ è un metodo. v1 + v2 (riga 16) si traduce in v1.operator+(v2).v1: per questo è const (Lezione 09).4 6. Si può scrivere anche v1 + v2 + v3.** per la potenza.1 + 1 fra due int resta 2.+ fra due oggetti resta un operatore con due operandi.a + b * c calcola prima b * c.Nota
Conviene definire un operatore solo quando il suo significato è uno solo. vettore * scalare è il prodotto per uno scalare. vettore * vettore potrebbe essere il prodotto scalare, il vettoriale o il prodotto componente per componente: in quel caso un metodo con un nome, dot() o cross(), è più chiaro.
In vettore_somma.cpp, dopo la riga 16, aggiungete Vettore2D v4 = v1 - v2;. Compila?
No: no match for ‘operator-’ (operand types are ‘Vettore2D’ and ‘Vettore2D’). Ogni operatore va definito a parte: operator+ non dà -.
throweccezioni.cpp
#include <iostream>
#include <stdexcept>
class DynamicArray {
private:
int size_;
double* data_;
public:
DynamicArray(int size)
: size_(size), data_(new double[size]) {}
~DynamicArray() {
delete[] data_;
std::cout << "distruttore\n";
}
double leggi(int indice) const {
if (indice < 0 || indice >= size_) {
throw std::out_of_range("indice non valido");
}
return data_[indice];
}
};Nella Lezione 09 leggi restituiva 0.0 per un indice non valido: un valore che può essere anche un dato.
Riga 17: throw interrompe la funzione e lancia un oggetto della classe std::out_of_range (da <stdexcept>), costruito con il suo messaggio: un’eccezione.
Copia e assegnamento sono omessi: qui l’oggetto non si copia.
try e catcheccezioni.cpp
Output:
distruttore
Errore: indice non valido
try; il blocco catch che segue la riceve, e e.what() restituisce il messaggio.leggi lancia l’eccezione, e il resto del blocco try (riga 26) viene saltato.Nell’output di try e catch, distruttore compare prima di Errore: ...:
try;a viene distrutta e il suo distruttore libera l’array;catch.I distruttori vengono eseguiti anche quando si esce da un blocco per un’eccezione: per questo il RAII funziona anche con le eccezioni, e nessun delete[] viene saltato.
Nel Laboratorio 05 la classe Matrix userà throw per gli indici e le dimensioni non validi. Le eccezioni si approfondiscono nella Lezione 19.
catchIn eccezioni.cpp, un esperimento alla volta:
try e il blocco catch (righe 23 e 27–29). Cosa stampa?Aborted (con clang su macOS: libc++abi: terminating due to uncaught exception of type std::out_of_range). Un’eccezione che nessun catch riceve termina il programma (Lezione 19), e i distruttori non vengono eseguiti: distruttore non compare.try e catch, e alla riga 27 scrivete std::invalid_argument al posto di std::out_of_range. Cosa succede?catch riceve solo il tipo di eccezione che indica, e qui nessun catch riceve std::out_of_range.Scopo: scrivere un operatore come metodo, quando l’operando di destra non è un oggetto della stessa classe ma un double.
Header e main sono dati; in Vettore2D.cpp va riscritta una sola riga.
Create Vettore2D.hpp, Vettore2D.cpp e scalare.cpp con il codice delle due slide seguenti, «Il file da completare» ed «Esercizio: header e main dati».
Completate operator*: restituisce un nuovo Vettore2D con le due componenti moltiplicate per scalare.
Aggiungete al CMakeLists.txt la riga add_executable(scalare scalare.cpp Vettore2D.cpp), poi compilate ed eseguite (l’output deve essere 15 20):
Vettore2D.cpp
#include "Vettore2D.hpp"
Vettore2D Vettore2D::operator+(const Vettore2D& altro) const {
return Vettore2D(x_ + altro.x_, y_ + altro.y_);
}
Vettore2D Vettore2D::operator*(double scalare) const {
// da completare: sostituite la riga seguente con un return
// di un Vettore2D con componenti x_ * scalare e y_ * scalare
return Vettore2D(0.0, 0.0);
}Come lo scheletro della Lezione 09, il file compila già e stampa 0 0. La riga 10 serve solo a questo: va sostituita, non lasciata accanto a quella nuova.
main dativ1 * 5.0 si traduce in v1.operator*(5.0): a sinistra c’è il vettore, a destra il double.
Vettore2D.cpp
L’output è 15 20: entrambe le componenti sono state moltiplicate per 5.
In scalare.cpp, prima di return 0;, aggiungete:
Compila?
No: no match for 'operator*' (operand types are 'double' and 'Vettore2D'). v1 * 5.0 diventa v1.operator*(5.0): il metodo si chiama sull’operando di sinistra. In 5.0 * v1 a sinistra c’è un double, che non ha metodi, quindi nessun operator* della classe può essere usato.
Per scrivere 5.0 * v1 serve una funzione, non un metodo: si dichiara fuori dalla classe e riceve i due operandi come parametri, nell’ordine in cui compaiono. 5.0 * v1 diventa operator*(5.0, v1).
Vettore2D.hpp
Vettore2D.cpp
v * s è v.operator*(s). Così la funzione non ha bisogno di leggere x_ e y_, che sono private.15 20 due volte.Stampa 2 2.
S b = a; usa il costruttore di copia generato dal compilatore: copia a.p in b.p. I due puntatori contengono lo stesso indirizzo, quello di x.*b.p = 2.0; scrive all’indirizzo contenuto in b.p, cioè in x.x vale 2, e anche *a.p, che legge lo stesso indirizzo.È una copia superficiale, ma qui non è un errore: S non possiede x e non la libera. Diventa un errore quando la classe libera la memoria nel distruttore, come DynamicArray.
Addestrare la rete vuol dire cercare il minimo di una funzione di molte variabili, la loss in funzione dei pesi. Il libro del Laboratorio di Calcolo (Barone, Marinari, Organtini, Ricci-Tersenghi, Programmazione Scientifica, capitolo «Metodi di ottimizzazione») tratta lo stesso problema per una funzione \(F(\mathbf{x})\) qualsiasi. Il metodo del gradiente scende lungo \(-\nabla F\):
\[ \mathbf{x}^{(n+1)} = \mathbf{x}^{(n)} - \eta\,\nabla F\big(\mathbf{x}^{(n)}\big) \]
Con \(\eta\) costante è la discesa del gradiente della Lezione 03, e \(\eta\) è il learning rate. Nel Laboratorio 02 l’avete provata su \(E(x) = x^2\), in una dimensione. Ora la portiamo in due, con il caso di prova del libro:
\[ F(x, y) = x^2 + 4y^2, \qquad \nabla F = (2x,\ 8y) \]
con il minimo in \((0, 0)\) e il punto di partenza \((2, 1)\). Con gli operatori di Vettore2D il passo si scrive in una riga, come la formula.
Scopo: usare gli operatori di Vettore2D per scrivere la discesa del gradiente in due dimensioni come la formula, e capire perché \(\eta\) ha un valore massimo.
Vettore2D.hpp e Vettore2D.cpp, con + e * per un double.const:
Vettore2D operator-(const Vettore2D& altro) const; differenza componente per componente;double norma() const; restituisce \(\sqrt{x^2 + y^2}\) (std::sqrt, con #include <cmath>).discesa.cpp, scrivete la funzione (non un metodo) Vettore2D gradF(const Vettore2D& p), che restituisce \((2x,\ 8y)\).discesa da completareIn discesa.cpp, dopo gradF, copiate questo scheletro. Mancano tre righe, indicate dai commenti.
discesa.cpp
int discesa(Vettore2D x, double eta, int max_passi) {
for (int n = 1; n <= max_passi; ++n) {
// da completare: il passo, x meno eta per il gradiente in x
double g = gradF(x).norma();
// da completare: se g < 1e-6 restituite n (convergenza)
// da completare: se g > 1e10 restituite -1 (divergenza)
}
return max_passi;
}Se esaurisce i max_passi passi senza convergere né divergere, la funzione restituisce max_passi.
Completate la funzione discesa della slide precedente.
Nel main definite double etas[4] = {0.1, 0.2, 0.24, 0.26}; e per ciascun eta chiamate discesa(Vettore2D(2.0, 1.0), eta, 100000). Stampate una riga eta = <valore>: <passi> passi, oppure eta = <valore>: diverge.
Aggiungete add_executable(discesa discesa.cpp Vettore2D.cpp) al CMakeLists.txt, poi compilate ed eseguite:
Perché con eta = 0.26 la discesa diverge, mentre su \(x^2\) (Laboratorio 02) convergeva? Scrivete \(x^{(n+1)}\) e \(y^{(n+1)}\) in funzione di \(x^{(n)}\) e \(y^{(n)}\).
Vettore2D.hppVettore2D.hpp
#pragma once
class Vettore2D {
private:
double x_, y_;
public:
Vettore2D(double x, double y) : x_(x), y_(y) {}
Vettore2D operator+(const Vettore2D& altro) const;
Vettore2D operator-(const Vettore2D& altro) const;
Vettore2D operator*(double scalare) const;
double norma() const;
double getX() const { return x_; }
double getY() const { return y_; }
};Due dichiarazioni nuove: operator- e norma(). Entrambe sono const, perché leggono le componenti senza modificarle.
Vettore2D.cppVettore2D.cpp
#include "Vettore2D.hpp"
#include <cmath>
Vettore2D Vettore2D::operator+(const Vettore2D& altro) const {
return Vettore2D(x_ + altro.x_, y_ + altro.y_);
}
Vettore2D Vettore2D::operator-(const Vettore2D& altro) const {
return Vettore2D(x_ - altro.x_, y_ - altro.y_);
}
Vettore2D Vettore2D::operator*(double scalare) const {
return Vettore2D(x_ * scalare, y_ * scalare);
}
double Vettore2D::norma() const {
return std::sqrt(x_ * x_ + y_ * y_);
}operator- ricalca operator+.
discesa.cpp
#include <iostream>
#include "Vettore2D.hpp"
Vettore2D gradF(const Vettore2D& p) {
return Vettore2D(2.0 * p.getX(), 8.0 * p.getY());
}
int discesa(Vettore2D x, double eta, int max_passi) {
for (int n = 1; n <= max_passi; ++n) {
1 x = x - gradF(x) * eta;
double g = gradF(x).norma();
if (g < 1e-6) return n;
if (g > 1e10) return -1;
}
return max_passi;
}operator*, poi operator-: il passo si scrive come la formula. Ogni operatore restituisce un temporaneo; l’ultimo viene assegnato a x.
x è passato per valore: discesa lavora su una copia del punto di partenza.
mainOutput:
eta = 0.1: 69 passi
eta = 0.2: 32 passi
eta = 0.24: 191 passi
eta = 0.26: diverge
Per scendere non serve il valore di \(F\), basta il gradiente. Anche la rete aggiorna i pesi con il solo gradiente della loss; il valore della loss serve a controllare l’addestramento.
Con \(\nabla F = (2x,\ 8y)\) le due componenti scendono separatamente: \(x^{(n+1)} = (1 - 2\eta)\, x^{(n)}\) e \(y^{(n+1)} = (1 - 8\eta)\, y^{(n)}\).
Converge solo se \(|1 - 2\eta| < 1\) e \(|1 - 8\eta| < 1\), cioè \(0 < \eta < 0{,}25\) (su \(x^2\) bastava \(\eta < 1\)).
| \(\eta\) | \(1 - 2\eta\) | \(1 - 8\eta\) | passi |
|---|---|---|---|
| 0,1 | 0,8 | 0,2 | 69 (lenta lungo \(x\)) |
| 0,2 | 0,6 | −0,6 | 32 |
| 0,24 | 0,52 | −0,92 | 191 (oscilla lungo \(y\)) |
| 0,26 | 0,48 | −1,08 | diverge lungo \(y\) |
Il limite lo fissa la direzione più ripida, \(y\). Nella rete, con tante direzioni più o meno ripide, \(\eta\) va scelto con cura (Laboratorio 02). L’esercizio verrà ripreso più avanti (Lezioni 12 e 20).