PDA

Visualizza la versione completa : [C++] Domanda su std::vector


boots
23-10-2012, 19:02
Ciao a Tutti,
Venendo dalla programmazione PHP/Java, mi è sorto un dubbio riguardo la gestione della memoria.
Io ho una struttura


typedef data{
int values[15];
} t_data;

Ed una classe con un vector di t_data ed un metodo che aggiunge un nuovo elemento


class DataManager{
private:
vector<t_data> valuesList;

public:
void add(){
t_data *tmp = new t_data;
// set del campo tmp->values
this->valuesList.push_back(*tmp);
}
}


Ok...la mia domanda è: Devo aggiungere nel distruttore una delete per ogni elemento del vector, o il compilatore è così gentile che lo fa lui quando l'istanza di DataManager viene distrutta?

Grazie a tutti

shodan
23-10-2012, 19:53
std::vector non può sapere se il dato con cui lo istanzi sia un oggetto o un puntatore.
E visto che il codice nel distruttore di std::vector deve valere per ogni tipo di dato istanziabile, la conclusione è ovvia: ci devi pensare tu.

E comunque a che ti serve creare un puntatore al dato se poi gli passi il dato?


void add(){
t_data *tmp = new t_data; /// ????
// set del campo tmp->values
this->valuesList.push_back(*tmp); /// ?????
}

Passagli direttamente il dato, no?


void add(){
t_data tmp;
this->valuesList.push_back(tmp);
}

boots
23-10-2012, 20:18
Grazie della risposta shodan.
Effettivamente avevo il sospetto di dover fare tutto da me.... :jam:



void add(){
t_data tmp;
this->valuesList.push_back(tmp);
}


Hai ragione...è che all'inizio volevo fare un vector di puntatori, poi ho cambiato idea...ed è uscita quella cosa :zizi:

Cmq ora che mi ci fai pensare, è più veloce/efficente fare come sopra
o



vector<t_data*> valuesList;

void add(){
t_data* tmp = new t_data;
this->valuesList.push_back(tmp);
}


tenendo presente che ogni secondo aggiungo un nuovo elemento ?

shodan
23-10-2012, 21:34
Definire "veloce" + "efficiente".

Nel primo caso viene creata una variabile sullo stack (più veloce), ma poi occorre copiarla nel vector (più lento).
Nel secondo caso crei la variabile nell'heap (più lento), ma poi copi solo un puntatore nel vector (più veloce).
Alla fine l'efficienza nella funzione si bilancia.
Questo al netto delle informazioni fornite.

Se comunque decidi per il vector di puntatori, usa gli shared_ptr (se li hai), in modo da lasciare a loro la gestione del puntatore interno.
Es.


vector<std::shared_ptr<t_data>> valuesList;

void add(){
std::shared_ptr tmp(new t_data);
this->valuesList.push_back(tmp);
}

o meglio ancora


this->valuesList.push_back(std::make_shared<t_data>());

boots
24-10-2012, 08:51
Grazie, sei stato molto gentile.

Non sapevo degli shared_prt...buono a sapersi!

Loading