C++ l'allocazione dinamica della memoria in una funzione - domanda newbie

Question

Sto indagando su una perdita di memoria e da quello che vedo, il problema si presenta in questo modo:

int main(){ 
    char *cp = 0; 
    func(cp); 
    //code 
    delete[] cp; 
} 

void func(char *cp){ 
    cp = new char[100]; 
} 

il codice // commento, mi aspettavo cp a puntare alla memoria allocata, ma è ancora un puntatore nullo che significa che non ho mai eliminato la memoria. Cosa sto facendo Wroing?

Answer 1

void func(char *cp){ 
    cp = new char[100]; 
} 

In questa funzione, char * cp è un "puntatore essere passato da copia" ciò significa che essi puntano allo stesso indirizzo di memoria ma non sono lo stesso puntatore . Quando si modifica il puntatore all'interno, rendendo al punto da qualche altra parte, il puntatore originale che è stata passata manterrà punta a 0.

Answer 2

Il parametro cp è una variabile locale della funzione - la modifica di esso non modifica nulla al di fuori della funzione. Un modo migliore per scrivere la funzione è:

char * func(){ 
    return new char[100]; 
} 

E non a che fare direttamente con la tua domanda, ma probabilmente si dovrebbe utilizzare std :: string e std :: vector, piuttosto che le matrici allocate in modo dinamico.

Answer 3

Assegnare cp il valore della memoria allocata. Tuttavia, questa è una variabile in pila: una copia di cp in main! cp è locale alla funzione si è in

quello che vuoi è un punto di riferimento:..

void func(char *& cp) 

Ciò alias cp ad essere il parametro passato in

Answer 4

si sta passando a cbuf , non cp.

Answer 5

La funzione è solo cambiando una copia di cp. Usa invece un riferimento.

Answer 6

Come Gman e Neil menzionati, al fine di lavorare si dovrà cambiare func a:

char* func();

o void func(char*& p);

che risolverà il tuo problema immediato.

C'è, tuttavia, un problema di manutenzione. In entrambi i casi, func restituisce un puntatore. Ciò che non è chiaro all'utente di func è che il puntatore restituito dovrà essere cancellato. Per questo motivo, in generale, evita questo costrutto a meno che non sia necessario il 100%. Piuttosto:

1. aiutare l'utente allocare la quantità corretta di memoria che possono poi essere passato a FUNC
2. Utilizzare un oggetto per memorizzare la memoria allocata. L'oggetto può quindi cancellare l'array di caratteri quando viene distrutto.

Così, per il codice C++, mi raccomando:

class CBuf 
{ 
public 
    CBuf() 
    { 
     iBuf = new char[100]; 
    } 
    ~CBuf 
    { 
     delete[] iBuf; 
    } 
    char* func() 
    { 
     //do stuff; 
     return iBuf; 
    } 
private: 
    char* iBuf; 
}; 

int main() 
    { 
    CBuf cb; 
    char* mychar = cb.func(); 
    //do stuff with character array 

    //destructor gets called here because cb goes out of scope 
    } 

Tuttavia, nella programmazione C in particolare, potrebbe essere necessario al 100% per avere qualche funzione di ordinamento per creare l'array. Pertanto nella programmazione C è possibile sostituire il distruttore con una funzione CreateCBuf e DestroyCBuf. In questo modo l'utente della tua libreria saprà che il buffer restituito deve essere distrutto.

Answer 7

Anche se i riferimenti sono meravigliosi nell'offrire un'astrazione intuitiva, rafforzata ulteriormente dal C++ 11 riferimenti rvalue per consentire la funzione concatenamento (e altri codici esoterici), si può affermare che essi forniscono alcuna sicurezza (cioè why is a reference considered safer than a pointer) Ci sono casi dove è meglio risolvere il precedente con un puntatore all'argomento della funzione del puntatore. In particolare quando è necessario mantenere un codebase simile in ansi c e C++.

#include <iostream> 

using namespace std; 

void func(char ** cp) { 
    *cp = new char[100]; 
    //do something useful 
    (*cp)[0] = 'A'; 
} 

void func(char *& cp) { 
    cp = new char[100]; 
    //do something useful 
    cp[0] = 'B'; 
} 

int main(int argc, char** argv) { 
    char * cp; 
    //pointer to pointer 
    func(&cp); 
    cout << "Index 0 : " << cp[0] << '\n' << flush; 
    delete[] cp; //remember to delete!! 
    //pointer to ref 
    func(cp); 
    cout << "Index 0: " << cp[0] << '\n' << flush; 
    delete[] cp; 
    return 0; 
} 

Ovviamente lo smaltimento delle risorse di memoria dall'ambito della funzione di instradamento disubbidisce a RAII.