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

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

Esempio: nella seguente classe, ho un vector, ma a causa di restrizioni esterne, i dati verranno passati come array in 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 passare in rassegna gli elementi o chiamare std::copy(). Ci sono metodi migliori?

Non dimenticare che puoi trattare i puntatori come iteratori:

w_.assign(w, w + len);

Usa la parola inizializza, quindi non è chiaro se si tratta di un compito una tantum o può accadere più volte.

Se hai solo bisogno di un'inizializzazione singola, puoi inserirla nel costruttore e utilizzare il costruttore del vettore di due iteratori:

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

Altrimenti usa assegnare come precedentemente suggerito:

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

Puoi "apprendere" automaticamente le dimensioni dell'array:

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

Eventualmente, puoi cambiare l'interfaccia in set_data come sopra. Accetta ancora un array in stile C come primo argomento. Capita solo di prenderlo per riferimento.

Come funziona

[Aggiornamento: vedi qui per una discussione più completa sull'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 funzione, invece decadrà in un puntatore e si perderanno le dimensioni. Ma in C ++, puoi passare un riferimento all'array.

Il passaggio di un array per riferimento richiede che i tipi corrispondano esattamente. La dimensione di un array fa parte del suo tipo. Ciò significa che possiamo usare il parametro modello N per imparare le dimensioni per noi.

Potrebbe essere ancora più semplice avere questa funzione che restituisce un vettore. Con le ottimizzazioni del compilatore appropriate in atto, 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);
}

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

Nel tuo caso:

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

• array ci darà un puntatore all'inizio dell'array (non ne ha preso il nome),
• std :: end (array) ci porterà un iteratore alla fine dell'array.

La rapida risposta generica:

std::vector<double> vec(carray,carray+carray_size); 

o domanda specifica:

std::vector<double> w_(w,w+len); 

in base a quanto sopra : non dimenticare che puoi considerare i puntatori come iteratori

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

Temo non ci sia modo più veloce per implementare (ri) inizializzare il tuo std::vector.