impedendo che i dati vengano liberati quando il vettore non rientra nell'ambito di applicazione

Question

Esiste un modo per trasferire la proprietà dei dati contenuti in un vettore std :: (indicato da, ad esempio T * dati) in un altro costrutto, impedendo di avere "dati" diventare un puntatore penzolante dopo che il vettore è andato fuori portata?

MODIFICA: NON VOGLIO COPIARE I DATI (che sarebbe una soluzione facile ma inefficace).

In particolare, mi piacerebbe avere qualcosa di simile:

template<typename T> 
    T* transfer_ownership(vector<T>&v){ 
    T*data=&v[0]; 
    v.clear(); 
    ...//<--I'd like to make v's capacity 0 without freeing data 
} 

int main(){ 
    T*data=NULL; 
    { 
     vector<double>v; 
     ...//grow v dynamically 
     data=transfer_ownership<double>(v); 
    } 
    ...//do something useful with data (user responsible for freeing it later) 
    // for example mxSetData(mxArray*A,double*data) from matlab's C interface 
} 

L'unica cosa che mi viene in mente per emulare questo è:

{ 
    vector<double>*v=new vector<double>(); 
    //grow *v... 
    data=(*v)[0]; 
} 

e poi saranno successivamente essere sia liberato i dati o (nel mio caso) usato come mxSetData (mxArray A, doppio dati). Tuttavia questo si traduce in una piccola perdita di memoria (struttura dei dati per la gestione della capacità di V, dimensioni, ecc ... ma non i dati stessi, ovviamente).

E 'possibile senza perdite?

Answer 1

Qualcosa come questo funziona per te?

int main() 
{ 
    double *data = 0; 
    { 
     vector<double> foo; 
     // insert some elements to foo 

     data = new double[foo.size()]; 
     std::copy(foo.begin(), foo.end(), &data[0]); 
    } 

    // Pass data to Matlab function. 
    delete [] data; 
    return 0; 
} 

Answer 2

Una soluzione semplice sarebbe scambiando il vettore con quello che si proprietario:

vector<double> myown; 

vector<double> someoneelses = foo(); 

std::swap(myown, someoneelses); 

Un approccio più duro ma forse migliore è scrivere il proprio allocatore per il vettore, e lasciarlo allocare su un pool tu mantenga. Nessuna esperienza personale, ma non è troppo complicata.

Answer 3

Se il vettore contiene valori, è possibile solo copiarli (cosa che accade quando si chiama std :: copy, std :: swap, ecc.). Se si conservano oggetti non primitivi in ​​un vettore e non si desidera copiarli (e utilizzarli in un'altra struttura dati), prendere in considerazione la memorizzazione dei puntatori

Answer 4

Il punto di utilizzo di un vettore std :: non deve preoccuparsi di i dati al suo interno:

• Mantieni il tuo vettore per tutta la tua applicazione;
• Passa con le altre funzioni (per evitare copie non necessarie);
• E le funzioni di avanzamento prevedono un puntatore a T con &v[0].

Se davvero non si vuole mantenere il vostro vettore, si dovrà copiare i dati - non è possibile trasferire la proprietà a causa std::vector garantisce distruggerà il suo contenuto quando si va fuori dal campo di applicazione. In tal caso, utilizzare l'algoritmo std::copy().

Answer 5

Poiché non si desidera copiare i dati tra contenitori, ma si desidera trasferire la proprietà dei dati tra contenitori, suggerisco di utilizzare un contenitore di puntatori intelligenti come segue.

void f() 
{ 
    std::vector<boost::shared_ptr<double> > doubles; 
    InitVector(doubles); 

    std::vector<boost::shared_ptr<double> > newDoubles(doubles); 
} 

Davvero non si può trasferire la proprietà dei dati tra contenitori standard senza fare una copia di esso, in quanto contenitori standard copiare sempre i dati che incapsulano. Se si desidera ridurre al minimo il sovraccarico di copia di oggetti costosi, è consigliabile utilizzare un puntatore intelligente conteggiato con riferimento per avvolgere la struttura dei dati costosi.boost::shared_ptr è adatto per questo compito poiché è abbastanza economico fare una copia di esso.