[c++] errore stranissimo con il distruttore? oO

[xnavigator]

ragazzi non capisco quest'errore

ho questo semplice codice:

#include <iostream>
#include <vector>
using namespace std;

class Ciao{
public:
	Ciao();
	~Ciao();
	int value;
};

int main() {
	
	vector<Ciao> myVector;

	return 0;
}

mi fa errore:
"1>main.obj : error LNK2019: riferimento al simbolo esterno "public: __thiscall Ciao::~Ciao(void)" (??1Ciao@@QAE@XZ) non risolto nella funzione "public: void * __thiscall Ciao::`scalar deleting destructor'(unsigned int)" (??_GCiao@@QAEPAXI@Z)"

se al posto del disturttore metto anche le parentesi graffe non mi fa più errore...
cioè se metto
~Ciao(){}

funziona bene...

e non riesoc a capire il perchè... soprattutto perchè non capisco fa quest'errore solo sul distruttore e il costruttore anhce senza graffe non fa nessun errore :S

[MItaly]

Credo che dipenda dal fatto che il distruttore di Ciao viene comunque referenziato (anche se non effettivamente richiamato, dato che non vengono aggiunti elementi al vector) nel distruttore del vector, nel momento in cui esso va a distruggere l'array che si trova al suo interno. Il costruttore invece non viene referenziato da nessuna parte in quel codice: l'unico costruttore che il vector richiede, infatti, è il costruttore di copie, che viene generato automaticamente dal compilatore se non è presente nella classe.

[xnavigator]

sto usando visual c++ 2009 express...
il distruttore non viene comunque generato dal compilatore?

[shodan]

Perché il linker si aspetta la definizione del distruttore, che non esiste finché non metti le {} o lo esplitici fuori dalla classe.
Il costruttore probabilmente è tolto dal compilatore visto che così com'è non serve.

[xnavigator]

Originariamente inviato da shodan

Il costruttore probabilmente è tolto dal compilatore visto che così com'è non serve.

se il costruttore non serve allora non dovrebbe servire neanceh il distruttore

[shodan]

Il distruttore è forse la funzione più importante di una classe, quindi se lo dichiari lo devi anche definire. Poco importa se ne sei convinto o no.
Considera che non è raro trovare classi o strutture simili:

class IDisposer {
   public:
       virtual void dispose()=0;
   protected:
       virtual ~IDisposer()=0;
};
IDisposer::~IDisposer{}  // senza di questo, il linker da errore.

[MItaly]

Originariamente inviato da shodan
Il costruttore probabilmente è tolto dal compilatore visto che così com'è non serve.

Credo che il punto piuttosto sia che non si fa riferimento al costruttore da nessuna parte in quel codice, per cui il compilatore non inserisce riferimenti ad esso nel modulo oggetto, di conseguenza il linker non ne può lamentare la mancanza. Il distruttore, invece, viene referenziato nel codice del distruttore del vettore, il compilatore non lo trova nell'unità di compilazione corrente e di conseguenza lo lascia come riferimento non risolto per il linker. Il linker non trova il distruttore da nessuna parte, per cui dà quell'errore.

[shodan]

Beh abbiamo detto la stessa cosa in fondo.

[xnavigator]

Originariamente inviato da MItaly
Credo che il punto piuttosto sia che non si fa riferimento al costruttore da nessuna parte in quel codice, per cui il compilatore non inserisce riferimenti ad esso nel modulo oggetto, di conseguenza il linker non ne può lamentare la mancanza. Il distruttore, invece, viene referenziato nel codice del distruttore del vettore, il compilatore non lo trova nell'unità di compilazione corrente e di conseguenza lo lascia come riferimento non risolto per il linker. Il linker non trova il distruttore da nessuna parte, per cui dà quell'errore.

ah ecco... ora si!

c'è da dire comunque che da come mi era stato spiegato ( [....] ) era stato detto che praticametne era la stessa cosa scrivere

Costruttore(); o Costruttore(){}
(stessa cosa per il distruttore)

quando, ora capisco, sono 2 cose completmaente diverse (con le graffe o senza)

[MItaly]

Sono due cose completamente diverse: con le graffe stai dichiarando e definendo un costruttore vuoto, mentre senza le graffe stai solo dichiarando il costruttore, per cui il compilatore si aspetta che sia effettivamente definito da un'altra parte.