[C++] Inspiegabile unresolved symbol

[TheClue/Nash]

Sono alle prese con il C++ da meno di due giorni...molto bello, ma continuo a preferire il C puro (voglio dire, tanto vale usare java, se si vuole sprecare memoria...)

cmq, ho un problema che probabilmente è ultrastupido, ma proprio per questo motivo...non riesco a risolverlo!

ho il linker che non riesce a risolvermi un oggetto 'Graph", nonostante il file in cui è definito/implementato sia stato compilato correttamente. Per completezza vi posto il risultato del mio make:

theclue@Asher ~/src/BFS $ make all
g++ -c -Wall nodelist.cpp
g++ -c -Wall testque.cpp
testque.cpp: In function ‘int main()’:
testque.cpp:8: warning: unused variable ‘pippo’
g++ -c -Wall graph.cpp
g++ testque.o nodelist.o graph.o -o testque
/usr/libexec/gcc/powerpc-apple-darwin8/4.0.1/ld: Undefined symbols:
Graph::Graph()
collect2: ld returned 1 exit status
make: *** [testque] Error 1

ma la cosa strana è che il file testque è

int main(void){
  Graph* pippo = new Graph();
  Graph graph;
}

...ma 'pippo' non da nessun errore!!! Come è possibile?

EDIT: trovato l'errore, ed era come ovvio stupidissimo...una dichiarazione di costruttore quando invece usavo il costruttore derivato dalla classe padre di Graph. Però, per mera curiosità accademica, continuo a chiedermi perché 'pippo' non dava quell'errore...

[menphisx]

Sono alle prese con il C++ da meno di due giorni...molto bello, ma continuo a preferire il C puro (voglio dire, tanto vale usare java, se si vuole sprecare memoria...)

Peggio di torvalds

[TheClue/Nash]

Originariamente inviato da menphisx
Peggio di torvalds

sai cos'è? mi confonde. Voglio dire...

se voglio fare qualche zozzeria e muovere i puntatori dove mi pare, lo faccio col C...
se voglio fare le cose per bene, seguendo uno schema per una buona organizzazione del codice ad oggetti estensibile, modificabile e tutto il resto e ho un sacco di memoria, uso il java...

il c++ mi confonde: da una parte mi viene voglia di fare le cose sporche alla maniera del c, dall'altra inconsciamente sono portato a usare classi e oggetti alla maniera del java...

cmq, nella mia opera di apprendimento forzato, riscontro altri errori. Sto cercando di capire bene lo schema di ereditarietà, ma ho qualche difficoltà. Ad esempio questo codice:

NodeList graph("abc");
Graph pippo("abc");

mi fornisce questo errore

testque.cpp: In function ‘int main()’:
testque.cpp:10: error: no matching function for call to ‘Graph::Graph(const char [4])’
graph.h:13: note: candidates are: Graph::Graph()
graph.h:13: note:                 Graph::Graph(const Graph&)

Il problema è che non capisco perché: Graph eredita da NodeList e NON ha costruttori, quindi...non dovrebbe ereditare il costruttore di NodeList che, appunto, ha come parametro un char*?

[Stoicenko]

No il costruttore non si eredita..

Se non viene definito esistono i 2 costruttori, senza parametri e di copia, standard che sono impliciti..

[Stoicenko]

Per fare quello che chiedi dovresti definire il costruttore standard cosi:

Graph(Char* a): NodeList(a) {}

Come vedi, il c++ non è il java, è un errore molto comune confondere la programmazione OOP pura con la programmazione orientata agli oggetti del c++..

Nel c++ una classe che eredita da un'altra contiene al suo interno un sottoggetto (tramite un puntatore a cui non hai accesso esplicitamente) della classe base quindi la derivazione non è un estensione..

[MItaly]

Originariamente inviato da TheClue/Nash
dall'altra inconsciamente sono portato a usare classi e oggetti alla maniera del java...

Segui questo schema e lascia le zozzerie solo nei punti dove la velocità è cruciale.

Il problema è che non capisco perché: Graph eredita da NodeList e NON ha costruttori, quindi...non dovrebbe ereditare il costruttore di NodeList che, appunto, ha come parametro un char*?

No, i costruttori non si ereditano. Al massimo puoi creare dei costruttori uguali nelle classi derivate che richiamano i costruttori della classe base. Ad esempio:

class Base
{
    int intero1;
public:
    Base(int Intero1)
    {
        intero1=Intero1;
    };
};
class Derivata : public Base
{
    int intero2;
public:
    Derivata(int Intero1) : Base(Intero1)
    {
        intero2=0;
    };
    Derivata(int Intero1, int Intero2) : Base(Intero1)
    {
        intero2=Intero2;
    };
};

.

[TheClue/Nash]

ok, quindi io risolvo creando un costruttore nella classe derivata, con la stessa signature di quello base, vuoto e con l'invocazione di quello base esplicita, così da "forzare" di chiamare subito il costruttore base...sembra aver senso

[Stoicenko]

Non è che forzi il costruttore..

Chiami solamente il costruttore del sottoggetto ClasseBase posseduto dalla classe derivata..

[TheClue/Nash]

ok!

ma questo vale in via generale per tutti metodi o solo per i costruttori/distruttori? cioè...se voglio usare un metodo di ClasseBase in ClasseFiglio devo cmq dichiarare quel metodo nel figlio?

class Pippo { void metodo(); }

class Pluto : public Pippo {}

Pippo::metodo(){ cout << "ciao"; }

int main(){ Pluto p; p.metodo(); }


...?

[LeleFT]

Tra parentesi... nemmeno in Java i costruttori vengono ereditati... si usa la stessa identica tecnica.


Ciao.