overloading costruttore C++

[robz14]

salve ragazzi sono alle prese con questo quesito..non mi è chiaro concettualmente cosa dover fare..vi scrivo il problema:
overloading di un costruttore di copia di un oggetto passato per valore a una funzione, laddove la copia deve riguardare una variabile membro di tipo stringa allocata in memoria dinamica.

[shodan]

Banalmente:
allocare il puntatore interno;
copiare il contenuto del puntatore della copia esterna nel puntatore appena allocato.

[robz14]

Un esempio al volo riusciresti a farlo per farmi capire meglio?

[shodan]

Al netto di controllo errori e altri metodi (tipo operator= comunque necessario), intendo qualcosa del genere.

class Foo {
    public:
        Foo() {}
        Foo(const char* str);
        Foo(const Foo& other);
        ~Foo();
   private:
       char* ptr;
       
};

inline Foo::Foo() : ptr(nullptr) {}

inline Foo::Foo(const char* str) : ptr(nullptr) {
    ptr = new char[strlen(str)+1];
    strcpy(ptr,str);
}

inline Foo::Foo(const Foo& other) : ptr(nullptr) {
    ptr = new char[strlen(other.ptr)+1];
    strcpy(ptr,other.ptr);
}

inline Foo::~Foo() {
   delete [] ptr;
}
//---
int main(/* etc */) {
    Foo foo = Foo("ciao mondo");
    // ma non 
    Foo foo1("ciao mondo);
    Foo foo2;
    foo2 = foo1; // QUI non è invocato il costruttore di copia ma l'operatore di assegnamento.
}

[robz14]

Io ho trovato questo esempio sul famoso Schildt..pensi vada bene come "risoluzione" del quesito?

#include <iostream>
#include <string>
#include <new>
#include <cstdlib>
using namespace std;


class array
{
	int *p;
	int dimensione;
	public:
	array (int dim)
		{
			cout<<"costruzione"<<endl;
			p=new int[dim];
			dimensione=dim;
		}


	~array() {
	    delete [] p;
	    cout<<"distruzione"<<endl;
	    }
	// costruttore di copie
	array(const array &arr);


	void imposta (int i, int j)
	{
		if(i>=0 && i <dimensione)
			p[i]=j;
	}


	int prendi(int i)
	{
		return p[i];
	}
};


// Costruttore di copie


array::array(const array &arr)
{
int i;
p=new int[arr.dimensione];
cout<<"costruttore di copie"<<endl;
for (i=0;i<arr.dimensione;i++)
p[i]= arr.p[i];
}




int main()
{
array num(10);
int i;
for(i=0;i<10;i++) 
{
    num.imposta(i,i);
}
for(i=9;i>=0;i--) 
{
    cout << num.prendi(i);
    cout <<"\n";
}


// i vettori num e x contengono gli stessi valori ma ciascun vettore
// si trova in aree diverse di memoria


// crea un altro array e lo inizializza con num
array x(num); // richiama il costruttore di copie;
for(i=0;i<10;i++)
{
    cout << num.prendi(i);
    cout <<"\n";
}
return 0;
}

[shodan]

Il tuo codice si riferisce a int, il mio a char (ed è proprio la base base). Però: si, va bene.
Entrambi nel costruttore di copia allocano il relativo puntatore e copiano i dati dal puntatore della classe copiata a quella copia.
Il meccanismo base è lo stesso.

[robz14]

Si giusto per essere più preciso meglio usare il char..grazie di tutto

[MItaly]

Occhio che se implementi un costruttore di copia e un distruttore è abbastanza imprescindibile implementare anche l'operatore di assegnazione, altrimenti con quello di default rischi problemi di questo tipo:

{
    Foo f("abcd");
    {
        Foo g("");
        g=f; // g copia il *puntatore* contenuto in f
    } // g viene distrutto e fa la delete[] del puntatore contenuto al suo interno, che è lo stesso di f
} // f viene distrutto, crash! la memoria a cui puntava è già stata deallocata!

Per implementare correttamente l'operatore di assegnazione senza ripetersi e senza rischiare di finire in uno stato inconsistente in caso di eccezioni la tecnica più semplice e sicura è il "copy & swap" .