Posso staccare un std :: vector <char> dai dati che contiene?

Question

Sto lavorando con una funzione che restituisce alcuni dati come std::vector<char> e un'altra funzione (si pensi alle API legacy) che elabora i dati e prende uno const char *, size_t len. C'è un modo per staccare i dati dal vettore in modo che il vettore possa uscire dall'ambito prima di chiamare la funzione di elaborazione senza copiando i dati contenuti nel vettore (è ciò che intendo implicare con scollegando).

Alcuni codice di schizzo per illustrare lo scenario:

// Generates data 
std::vector<char> generateSomeData(); 

// Legacy API function which consumes data 
void processData(const char *buf, size_t len); 

void f() { 
    char *buf = 0; 
    size_t len = 0; 
    { 
     std::vector<char> data = generateSomeData(); 
     buf = &data[0]; 
     len = data.size(); 
    } 

    // How can I ensure that 'buf' points to valid data at this point, so that the following 
    // line is okay, without copying the data? 
    processData(buf, len); 
} 

Answer 1

void f() { 
    char *buf = 0; 
    size_t len = 0; 
    std::vector<char> mybuffer; // exists if and only if there are buf and len exist 
    { 
     std::vector<char> data = generateSomeData(); 
     mybuffer.swap(data); // swap without copy 
     buf = &mybuffer[0]; 
     len = mybuffer.size(); 
    } 

    // How can I ensure that 'buf' points to valid data at this point, so that the following 
    // line is okay, without copying the data? 
    processData(buf, len); 
} 

Answer 2

io non lo consiglio, ma:

char* ptr = NULL; 
int len = -1; 
{ 
    vector<char> vec; 
    /* ... fill vec with data ... */ 
    vec.push_back(NULL); // dont forget to null terminate =) 
    ptr = &vec.front(); 
    len = vec.size(); 
    // here goes... 
    memset((void*)&vec, 0, sizeof(vec)); 
} 
// vec is out of scoop, but you can still access it's old content via ptr. 
char firstVal = ptr[0]; 
char lastVal = ptr[len-1]; 
delete [] ptr; // don't forget to free 

Voila!

Questo codice è in realtà abbastanza sicuro poiché il distruttore di VEC chiamerà delete [] 0;, operazione sicura (a meno che non si abbia qualche strana implementazione di stl).

Answer 3

La soluzione più semplice è nemmeno stato ancora presentato:

void f() { 
    std::vector<char> data = generateSomeData(); 

    processData(&data[0], data.size()); 
}