Zurückgeben eines Klasse-Objekt mit einem Zeiger

Question

ich eine Klasse

haben

class Foo 
{ 
    public: 
    char* ptr; 
    Foo() { ptr=new char [10]; } 
    ~Foo() { delete [] ptr; } 
}; 

Ich habe gelernt, dass ein Objekt dieser Klasse Rückkehr ist nicht möglich, da der dynamisch zugewiesenen Zeiger delete ‚ed ist und erzeugt einen baumelnden Zeiger in der Aufruf der Funktion

Also wie kann ich ein Objekt dieser Klasse?

Foo Bar() 
{ 
    Foo obj; 
    return obj; 
} 

Kann es durch Hinzufügen eines Copykonstruktor

Foo::Foo(const Foo& obj) 
{ 
    ptr = new char [10]; 
    for(int i = 0 ; i < 10 ;++i) 
     ptr [i] = obj.ptr[i]; 
} 

und die Funktion als

Foo Bar() 
{ 
    Foo obj; 
    return Foo(obj);  //invokes copy constructor 
} 

Hinweis Dies sind nur gelöst werden Darstellung der tatsächlichen Klasse ich will und ist nicht erstellt nach den empfohlenen Standards (dh. Bitte sagen Sie mir nicht zu verwenden std::string oder std::vector).

Answer 1

Also wie kann ich ein Objekt dieser Klasse ??

Sie müssen den Kopierkonstruktor und den Kopierzuweisungsoperator implementieren, die den Speicher ordnungsgemäß verwalten.

// Copy constructor 
Foo(Foo const& copy) : ptr(new char[strlen(copy.ptr)+1]) 
{ 
    strcpy(ptr, copy.ptr); 
} 

// Copy assignment operator 
Foo& operator=(Foo const& rhs) 
{ 
    // Don't do anything for self assignment 
    if (this != &rhs) 
    { 
     delete [] ptr; 
     ptr = new char[strlen(rhs.ptr)+1]); 
     strcpy(ptr, rhs.ptr); 
    } 
    return *this; 
} 

Wenn ptr ist immer ein Array von 10 char s los zu sein, müssen Sie den Kopierkonstruktor und kopieren Zuordnung zu überdenken.

// Copy constructor 
Foo(Foo const& copy) : ptr(new char[10]) 
{ 
    memcpy(ptr, copy.ptr, 10); 
} 

// Copy assignment operator 
Foo& operator=(Foo const& rhs) 
{ 
    // Don't do anything for self assignment 
    if (this != &rhs) 
    { 
     memcpy(ptr, rhs.ptr, 10); 
    } 
    return *this; 
}