¿Cuál es la forma más sencilla de convertir una matriz en vector?
void test(vector<int> _array)
{
...
}
int x[3]={1, 2, 3};
test(x); // Syntax error.
Quiero convertir x de una matriz int a un vector de la manera más sencilla.
Use el vector
constructor que toma dos iteradores, tenga en cuenta que los punteros son iteradores válidos y use la conversión implícita de matrices a punteros:
int x[3] = {1, 2, 3};
std::vector<int> v(x, x + sizeof x / sizeof x[0]);
test(v);
o
test(std::vector<int>(x, x + sizeof x / sizeof x[0]));
dónde sizeof x / sizeof x[0]
está obviamente 3
en este contexto; es la forma genérica de obtener el número de elementos en una matriz. Tenga en cuenta que x + sizeof x / sizeof x[0]
apunta un elemento más allá del último elemento.
vector<int> a(5,10);
meanmake room for 5
int` y los inicializo con 10. Pero, ¿cómo funciona su x, x + ...? ¿puedes explicar?vector<int>::vector(size_type, int)
, seleccionavector<int>::vector(int*, int*)
, lo que copia el rango indicado por ese par de punteros. El primero es sobrecarga (2), el segundo es sobrecarga (4) aquísizeof x / sizeof x[0] == std::extent<decltype(x)>::value
Personalmente, me gusta bastante el enfoque de C ++ 2011 porque no requiere que use
sizeof()
ni recuerde ajustar los límites de la matriz si alguna vez cambia los límites de la matriz (y puede definir la función relevante en C ++ 2003 si lo desea también ):#include <iterator> #include <vector> int x[] = { 1, 2, 3, 4, 5 }; std::vector<int> v(std::begin(x), std::end(x));
Obviamente, con C ++ 2011 es posible que desee usar listas de inicializadores de todos modos:
std::vector<int> v({ 1, 2, 3, 4, 5 });
fuente
std::vector<T>
siempre es dueño de losT
objetos. Esto tiene dos implicaciones: al insertar un objeto en un vector, se copian y se colocan en la memoria. Para objetos razonablemente pequeños, por ejemplo, secuencias de cadenas cortas, la colocación es una ganancia de rendimiento importante. Si sus objetos son grandes y costosos de copiar, es posible que desee almacenar punteros [de alguna manera administrados por recursos] a los objetos. Qué enfoque es más eficiente depende de los objetos, pero usted tiene la opción.Los punteros se pueden utilizar como cualquier otro iterador:
int x[3] = {1, 2, 3}; std::vector<int> v(x, x + 3); test(v)
fuente
const size_t X_SIZE = 3;
para denotar el tamaño de la matriz o calculándolo a partir de sizeof. Omití esa parte en aras de la legibilidad.Estás haciendo la pregunta incorrecta aquí: en lugar de forzar todo en un vector, pregunta cómo puedes convertir la prueba para que funcione con iteradores en lugar de un contenedor específico. También puede proporcionar una sobrecarga para mantener la compatibilidad (y manejar otros contenedores al mismo tiempo de forma gratuita):
void test(const std::vector<int>& in) { // Iterate over vector and do whatever }
se convierte en:
template <typename Iterator> void test(Iterator begin, const Iterator end) { // Iterate over range and do whatever } template <typename Container> void test(const Container& in) { test(std::begin(in), std::end(in)); }
Lo que te permite hacer:
int x[3]={1, 2, 3}; test(x); // Now correct
( Demostración de Ideone )
fuente
Una forma sencilla puede ser el uso de una
assign()
función predefinida en lavector
clase.p.ej
array[5]={1,2,3,4,5}; vector<int> v; v.assign(array, array+5); // 5 is size of array.
fuente