¿Cómo inicializar std :: vector desde la matriz de estilo C?

¿Cuál es la forma más barata de inicializar una std::vectormatriz de estilo C?

Ejemplo: en la siguiente clase, tengo un vector, pero debido a restricciones externas, los datos se pasarán como una matriz de estilo C:

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

Obviamente, puedo llamar w_.resize()y luego recorrer los elementos, o llamar std::copy(). ¿Hay mejores métodos?

No olvides que puedes tratar los punteros como iteradores:

w_.assign(w, w + len);

Utiliza la palabra inicializar, por lo que no está claro si se trata de una tarea única o puede suceder varias veces.

Si solo necesita una inicialización única, puede ponerla en el constructor y usar el constructor de dos iteradores de vectores:

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

De lo contrario, utilice asignar como se sugirió anteriormente:

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

Puede 'aprender' el tamaño de la matriz automáticamente:

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

Con suerte, puede cambiar la interfaz a set_data como se indicó anteriormente. Todavía acepta una matriz de estilo C como primer argumento. Simplemente lo toma por referencia.

Cómo funciona

[Actualización: vea aquí para una discusión más completa sobre el aprendizaje del tamaño]

Aquí hay una solución más general:

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

Esto funciona porque la matriz se pasa como una referencia a una matriz. En C / C ++, no puede pasar una matriz como una función, sino que se descompondrá en un puntero y perderá el tamaño. Pero en C ++, tú puedes pasar una referencia a la matriz.

Pasar una matriz por referencia requiere que los tipos coincidan exactamente. El tamaño de una matriz es parte de su tipo. Esto significa que podemos usar el parámetro de plantilla N para conocer el tamaño para nosotros.

Puede ser aún más simple tener esta función que devuelve un vector. Con las optimizaciones apropiadas del compilador en efecto, esto debería ser más rápido de lo que parece.

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

Bueno, Pavel estuvo cerca, pero incluso hay una solución más simple y elegante para inicializar un contenedor secuencial desde una matriz de estilo ac.

En tu caso:

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

• array nos dará un puntero al comienzo de la matriz (no capturó su nombre),
• std :: end (array) nos dará un iterador al final de la matriz.

La respuesta genérica rápida:

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

o pregunta específica:

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

basado en lo anterior : no olvide que puede tratar los punteros como iteradores

std::vector<double>::assignes el camino a seguir, porque es un código pequeño . Pero, ¿cómo funciona en realidad? ¿No cambia el tamaño y luego copia? En la implementación MS de STL que estoy usando, lo hace exactamente.

Me temo que no hay una forma más rápida de implementar (re) inicializar su std::vector.