[C++] Domanda su std::vector

[boots]

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]

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]

Grazie della risposta shodan.
Effettivamente avevo il sospetto di dover fare tutto da me....

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

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]

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]

Grazie, sei stato molto gentile.

Non sapevo degli shared_prt...buono a sapersi!