[C++] costruttori e distruttori

[ilmassa]

Salve, questo è il secondo topic che scrivo, dopo i puntatori ..
Volevo chiedervi una cosa... quando provo a definire un costruttore o un distruttore il compilatore mi segna alcuni errori.
Allora ho preso dal sito un esempio (il primo programma di esempio):

http://programmazione.html.it/guide/...e-distruttori/

Stranamente però ho notato che mi dava alcuni errori...
Ho corretto l'errore di battitura:
#inclde "Conversione.h"
in:
#include "Conversione.h"

Però nonostante questo, quando vado a compilare mi da il seguente errore (simile a quando provavo a farlo da solo):

contatore.cpp:5: error: expected unqualified-id before ')' token contatore.cpp:15: error: destructors must be member functions

Il primo errore punta a :

Conversione( ) { cout << "Inizio della conversione"; valore_lira = 0; // Inizializzazione della variabile valore_lira valore_euro = 0.0; // Inizializzazione della variabile valore_euro };

Il secondo punta a:

~Conversione( ) { cout << "Fine della conversionen"; };

Ci sono altri errori in quel codice, oppure c'è qualcosa che non va da me ?

[oregon]

Ci sono degli errori in quel codice ... probabilmente non è stato mai controllato dopo la pubblicazione ...

#include <iostream>
#include "Conversione.h"

using namespace std;

Conversione::Conversione()
...

Conversione::~Conversione( )

...

cout << conv.valore_lira << " in lire, vale " << conv.valore_euro << " Euro.";

[ilmassa]

In pratica anche quando si richiama un costruttore e un distruttore va specificata ugualmente la classe.
Grazie mille (aveva fatto lo stesso errore il libro). Comunque funziona tutto adesso.

Riguardo il distruttore, ho letto che posso invocarlo anche io(tramite la chiamata dal main):

conv.~Conversione();

Altrimenti si invoca da solo, al termine della parte di codice...
La mia domanda è ... perchè se lo invoco dal main, aggiungendo:

conv.~Conversione();

Fa uscire due volte la scritta (cout<<):

Fine della conversione

Cioè, è come se lo avesse già deallocato dalla memoria, e quello che mi fa vedere è solo l'operazione di output della scritta? oppure accade altro di strano?

La modifica sarebbe questa nel main:

#include <stdlib.h>
#include <iostream>
using namespace std;
#include "Conversione.h"

int main( )
{
Conversione conv;
conv.ottieni_valore( );
conv.valore_euro = conv.converti_lira_in_euro( );
cout << conv.valore_lira <<" in lire, vale " << conv.valore_euro << " Euro."<<endl;
conv.~Conversione();    //aggiunto questo per prova
return(0);
}

Conversione.h funzionante (senza modifiche)

class Conversione
{
public:
Conversione();
~Conversione();

long valore_lira;
float valore_euro;

void ottieni_valore();
float converti_lira_in_euro( );
};

Conversione.cpp funzionante (senza modifiche)

#include <iostream>
using namespace std;
#include "Conversione.h"

Conversione::Conversione( )
{
cout << "Inizio della conversione";
valore_lira = 0;
// Inizializzazione della variabile valore_lira
valore_euro = 0.0;
// Inizializzazione della variabile valore_euro
};

Conversione::~Conversione( )
{
cout << "Fine della conversione";
};

void Conversione::ottieni_valore( )
{
cout << "Inserire il valore in lire: " ;
cin >> valore_lira;
cout << endl;
};

float Conversione:: converti_lira_in_euro( )
{
float risultato;
risultato = ((float) valore_lira) / (float) 1936.27;
return risultato;
};

Giusto per chiarire l'ultima cosa, dato che sul libro non l'ho trovata scritta(se si chiama anche dal main cosa succede?).


Cioè , ho letto che: o la chiami tu, o fa da solo l'operazione (di deallocazione di memoria).
Però perchè se la chiamo io, fa anche l'operazione automatica (la ripete 2 volte)?

[oregon]

Originariamente inviato da ilmassa
Riguardo il distruttore, ho letto che posso invocarlo anche io(tramite la chiamata dal main):

conv.~Conversione();

Altrimenti si invoca da solo, al termine della parte di codice...

Non altrimenti ... il distruttore viene comunque invocato quando l'istanza della classe viene distrutta (appunto). Non ha senso che lo chiami tu.

La mia domanda è ... perchè se lo invoco dal main, aggiungendo:

conv.~Conversione();

Fa uscire due volte la scritta (cout<<):

Fine della conversione

Appunto perchè comunque viene invocato alla distruzione dell'istanza.

Cioè, è come se io avessi distrutto già l'operatore

operatore? Quale operatore hai distrutto?

Forse intendi l'istanza della classe ...

Comunque, NON devi chiamare il distruttore.

[ilmassa]

Cioè, è come se io avessi distrutto già l'operatore

Sbagliato a scrivere, volevo dire come se avesse deallocato già la memoria.
Modifico altrimenti se legge qualche altra persona si sbaglia.

Comunque thx, capito tutto, quindi non c'è bisogno di richiamarlo .