Come inizializzare std :: vector dall'array in stile C?

Question

Qual è il modo più economico per inizializzare uno std::vector da un array in stile C?

Esempio: Nel seguente classe, ho un vector, ma a causa delle restrizioni esterne, i dati verranno trasmessi come matrice stile C:

class Foo { 
    std::vector<double> w_; 
public: 
    void set_data(double* w, int len){ 
    // how to cheaply initialize the std::vector? 
} 

Ovviamente, posso chiamare w_.resize() e poi cappio sopra gli elementi, o chiamare std::copy(). Ci sono metodi migliori?

Answer 1

Non dimenticate che è possibile trattare i puntatori come iteratori:

w_.assign(w, w + len); 

Answer 2

si utilizza la parola inizializzare quindi non è chiaro se questo è l'assegnazione di una volta o può accadere più volte.

Se avete solo bisogno di un'inizializzazione di una volta, si può mettere nel costruttore e utilizzare i due iteratore vettore costruttore:

Foo::Foo(double* w, int len) : w_(w, w + len) { } 

Altrimenti utilizzare assegnare come suggerito in precedenza:

void set_data(double* w, int len) 
{ 
    w_.assign(w, w + len); 
} 

Answer 3

std::vector<double>::assign è la strada da percorrere, perché è il piccolo codice. Ma come funziona, in realtà? Non si ridimensiona e quindi copia? Nell'implementazione di MS di STL che sto usando, fa esattamente così.

Ho paura che non ci sia il modo più veloce per implementare (ri) l'inizializzazione del tuo std::vector.

Answer 4

Si puo 'imparare' la dimensione dell'array automaticamente:

template<typename T, size_t N> 
void set_data(const T (&w)[N]){ 
    w_.assign(w, w+N); 
} 

Eventualmente, è possibile modificare l'interfaccia per set_data come sopra. Accetta ancora un array in stile C come primo argomento. Capita semplicemente di prenderlo per riferimento.

---

Come funziona

[Update: Vedere here per una discussione più completa per l'apprendimento delle dimensioni]

Ecco una soluzione più generale:

template<typename T, size_t N> 
void copy_from_array(vector<T> &target_vector, const T (&source_array)[N]) { 
    target_vector.assign(source_array, source_array+N); 
} 

Questo funziona perché l'array viene passato come riferimento a un array. In C/C++, non è possibile passare una matrice come una funzione, ma decadrà in un puntatore e si perde la dimensione. Ma in C++, è possibile passare un riferimento alla matrice.

Il passaggio di un array per riferimento richiede che i tipi corrispondano esattamente. La dimensione di un array è parte del suo tipo. Ciò significa che possiamo utilizzare il parametro del modello N per apprendere la dimensione per noi.

Potrebbe essere ancora più semplice avere questa funzione che restituisce un vettore. Con le opportune ottimizzazioni del compilatore in vigore, questo dovrebbe essere più veloce di quanto sembri.

template<typename T, size_t N> 
vector<T> convert_array_to_vector(const T (&source_array)[N]) { 
    return vector<T>(source_array, source_array+N); 
} 

Answer 5

Beh, Pavel era vicino, ma c'è anche una soluzione più semplice ed elegante per inizializzare un contenitore sequenziale da un array c stile.

Nel tuo caso:

w_ (array, std::end(array)) 

• serie ci ottenere un puntatore all'inizio della matrice (non cogliere il suo nome),
• std :: end (array) otterrà noi un iteratore alla fine dell'array.