Wie initialisiere ich std :: vector aus einem Array im C-Stil?

Was ist der billigste Weg, um ein std::vectorArray aus einem C-Stil zu initialisieren ?

Beispiel: In der folgenden Klasse habe ich eine vector, aber aufgrund externer Einschränkungen werden die Daten als Array im C-Stil übergeben:

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

Natürlich kann ich w_.resize()die Elemente aufrufen und dann durchlaufen oder aufrufen std::copy(). Gibt es bessere Methoden?

Vergessen Sie nicht, dass Sie Zeiger als Iteratoren behandeln können:

w_.assign(w, w + len);

Sie verwenden das Wort "Initialisieren", sodass unklar ist, ob es sich um eine einmalige Zuweisung handelt oder ob sie mehrmals auftreten kann.

Wenn Sie nur eine einmalige Initialisierung benötigen, können Sie diese in den Konstruktor einfügen und den Konstruktor mit zwei Iteratorvektoren verwenden:

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

Verwenden Sie andernfalls zuweisen wie zuvor vorgeschlagen:

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

Sie können die Größe des Arrays automatisch "lernen":

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

Hoffentlich können Sie die Schnittstelle wie oben in set_data ändern. Es akzeptiert weiterhin ein Array im C-Stil als erstes Argument. Es nimmt es einfach als Referenz.

Wie es funktioniert

[Update: Sehen Sie hier für eine umfassendere Diskussion über die Größe Lernen]

Hier ist eine allgemeinere Lösung:

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);
}

Dies funktioniert, weil das Array als Referenz auf ein Array übergeben wird. In C / C ++ können Sie ein Array nicht als Funktion übergeben, sondern es zerfällt in einen Zeiger und Sie verlieren die Größe. In C ++ können Sie jedoch einen Verweis auf das Array übergeben.

Um ein Array als Referenz zu übergeben, müssen die Typen genau übereinstimmen. Die Größe eines Arrays ist Teil seines Typs. Dies bedeutet, dass wir den Vorlagenparameter N verwenden können, um die Größe für uns zu lernen.

Es könnte noch einfacher sein, diese Funktion zu haben, die einen Vektor zurückgibt. Bei entsprechenden Compiler-Optimierungen sollte dies schneller sein, als es aussieht.

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);
}

Nun, Pavel war nah dran, aber es gibt noch eine einfachere und elegantere Lösung, um einen sequentiellen Container aus einem Array im AC-Stil zu initialisieren.

In deinem Fall:

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

• Array gibt uns einen Zeiger auf den Anfang des Arrays (hat seinen Namen nicht verstanden),
• Mit std :: end (Array) erhalten wir einen Iterator zum Ende des Arrays.

Die schnelle generische Antwort:

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

oder fragenspezifisch:

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

basierend auf oben : Vergessen Sie nicht, dass Sie Zeiger als Iteratoren behandeln können

std::vector<double>::assignist der richtige Weg, weil es wenig Code ist . Aber wie funktioniert das eigentlich? Wird die Größe nicht geändert und dann kopiert? In der MS-Implementierung von STL verwende ich es genau so.

Ich fürchte, es gibt keinen schnelleren Weg , um Ihre (Neu-) Initialisierung zu implementieren std::vector.