¿Cómo se copia el contenido de una matriz en un std :: vector en C ++ sin bucles?

Tengo una matriz de valores que se pasa a mi función desde una parte diferente del programa que necesito almacenar para su posterior procesamiento. Como no sé cuántas veces se llamará a mi función antes de que sea el momento de procesar los datos, necesito una estructura de almacenamiento dinámica, por lo que elegí una std::vector. No quiero tener que hacer el ciclo estándar para push_backtodos los valores individualmente, sería bueno si pudiera copiarlo todo usando algo similar a memcpy.

Si puede construir el vector después de obtener la matriz y el tamaño de la matriz, simplemente puede decir:

std::vector<ValueType> vec(a, a + n);

... asumiendo que aes su matriz y nes la cantidad de elementos que contiene. De lo contrario, std::copy()w / resize()hará el truco.

Me mantendría alejado a memcpy()menos que pueda estar seguro de que los valores son tipos de datos antiguos (POD).

Además, vale la pena señalar que ninguno de estos realmente evita el bucle for; es solo una cuestión de si debe verlo en su código o no. O (n) rendimiento en tiempo de ejecución es inevitable para copiar los valores.

Por último, tenga en cuenta que las matrices de estilo C son contenedores perfectamente válidos para la mayoría de los algoritmos STL: el puntero sin formato es equivalente a begin(), y ( ptr + n) es equivalente a end().

Ha habido muchas respuestas aquí y casi todas harán el trabajo.

Sin embargo, ¡hay algunos consejos engañosos!

Estas son las opciones:

vector<int> dataVec;

int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
unsigned dataArraySize = sizeof(dataArray) / sizeof(int);

// Method 1: Copy the array to the vector using back_inserter.
{
    copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}

// Method 2: Same as 1 but pre-extend the vector by the size of the array using reserve
{
    dataVec.reserve(dataVec.size() + dataArraySize);
    copy(&dataArray[0], &dataArray[dataArraySize], back_inserter(dataVec));
}

// Method 3: Memcpy
{
    dataVec.resize(dataVec.size() + dataArraySize);
    memcpy(&dataVec[dataVec.size() - dataArraySize], &dataArray[0], dataArraySize * sizeof(int));
}

// Method 4: vector::insert
{
    dataVec.insert(dataVec.end(), &dataArray[0], &dataArray[dataArraySize]);
}

// Method 5: vector + vector
{
    vector<int> dataVec2(&dataArray[0], &dataArray[dataArraySize]);
    dataVec.insert(dataVec.end(), dataVec2.begin(), dataVec2.end());
}

Para abreviar una historia larga, el Método 4, usar vector :: insert, es el mejor para el escenario de bsruth.

Aquí hay algunos detalles sangrientos:

Método 1 es probablemente el más fácil de entender. Simplemente copie cada elemento de la matriz y empújelo en la parte posterior del vector. Por desgracia, es lento. Debido a que hay un bucle (implícito con la función de copia), cada elemento debe tratarse individualmente; no se pueden realizar mejoras de rendimiento basadas en el hecho de que sabemos que la matriz y los vectores son bloques contiguos.

El método 2 es una mejora de rendimiento sugerida para el método 1; simplemente reserve previamente el tamaño de la matriz antes de agregarla. Para arreglos grandes, esto podría ayudar. Sin embargo, el mejor consejo aquí es que nunca use la reserva a menos que el perfil sugiera que puede obtener una mejora (o debe asegurarse de que sus iteradores no se invaliden). Bjarne está de acuerdo . Por cierto, descubrí que este método funcionaba más lento la mayor parte del tiempo, aunque estoy luchando por explicar de manera integral por qué era regularmente significativamente más lento que el método 1 ...

El método 3 es la solución de la vieja escuela: ¡arroje algo de C al problema! Funciona bien y rápido para tipos POD. En este caso, es necesario llamar a resize ya que memcpy funciona fuera de los límites del vector y no hay forma de decirle a un vector que su tamaño ha cambiado. Además de ser una solución desagradable (¡copia de bytes!), Recuerde que esto solo se puede usar para tipos POD . Nunca usaría esta solución.

El método 4 es la mejor manera de hacerlo. Su significado es claro, es (generalmente) el más rápido y funciona para cualquier objeto. No hay inconveniente en utilizar este método para esta aplicación.

Método 5 es una modificación del Método 4: copia la matriz en un vector y luego agrégala. Buena opción, generalmente rápida y clara.

Finalmente, sabe que puede usar vectores en lugar de matrices, ¿verdad? Incluso cuando una función espera matrices de estilo c, puede usar vectores:

vector<char> v(50); // Ensure there's enough space
strcpy(&v[0], "prefer vectors to c arrays");

¡Espero que eso ayude a alguien!

Si todo lo que está haciendo es reemplazar los datos existentes, puede hacer esto

std::vector<int> data; // evil global :)

void CopyData(int *newData, size_t count)
{
   data.assign(newData, newData + count);
}

std :: copy es lo que está buscando.

Como solo puedo editar mi propia respuesta, voy a hacer una respuesta compuesta de las otras respuestas a mi pregunta. Gracias a todos los que respondieron.

Usando std :: copy , esto aún se repite en segundo plano, pero no tiene que escribir el código.

int foo(int* data, int size)
{
   static std::vector<int> my_data; //normally a class variable
   std::copy(data, data + size, std::back_inserter(my_data));
   return 0;
}

Usando memcpy normal . Probablemente se utilice mejor para tipos de datos básicos (es decir, int) pero no para matrices más complejas de estructuras o clases.

vector<int> x(size);
memcpy(&x[0], source, size*sizeof(int));

Evita la memoria, digo. No hay razón para meterse con las operaciones del puntero a menos que sea necesario. Además, solo funcionará para tipos POD (como int), pero fallará si se trata de tipos que requieren construcción.

int dataArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//source

unsigned dataArraySize = sizeof(dataArray) / sizeof(int);

std::vector<int> myvector (dataArraySize );//target

std::copy ( myints, myints+dataArraySize , myvector.begin() );

//myvector now has 1,2,3,...10 :-)

Otra respuesta más, dado que la persona dijo "No sé cuántas veces se llamará a mi función", podría usar el método de inserción de vectores de esta manera para agregar matrices de valores al final del vector:

vector<int> x;

void AddValues(int* values, size_t size)
{
   x.insert(x.end(), values, values+size);
}

Me gusta de esta manera porque la implementación del vector debería poder optimizarse para la mejor manera de insertar los valores según el tipo de iterador y el tipo en sí. De alguna manera está respondiendo sobre la implementación de stl.

Si necesita garantizar la velocidad más rápida y sabe que su tipo es un tipo POD, le recomendaría el método de cambio de tamaño en la respuesta de Thomas:

vector<int> x;

void AddValues(int* values, size_t size)
{
   size_t old_size(x.size());
   x.resize(old_size + size, 0);
   memcpy(&x[old_size], values, size * sizeof(int));
}

Además de los métodos presentados anteriormente, debe asegurarse de usar std :: Vector.reserve (), std :: Vector.resize (), o construir el vector al tamaño, para asegurarse de que su vector tenga suficientes elementos en para guardar sus datos. si no, dañará la memoria. Esto es cierto para std :: copy () o memcpy ().

Esta es la razón para usar vector.push_back (), no puede escribir más allá del final del vector.

Suponiendo que sepa qué tan grande es el elemento del vector:

std::vector<int> myArray;
myArray.resize (item_count, 0);
memcpy (&myArray.front(), source, item_count * sizeof(int));

http://www.cppreference.com/wiki/stl/vector/start