Puntero a un Vector

Question

Tengo un puntero a un vector. Ahora, ¿cómo puedo leer el contenido del vector a través del puntero? Sé que esta es una pregunta básica, pero no puedo encontrar una respuesta para el mismo. (C++)

Answer 1

Hay muchas soluciones, aquí hay unos pocos que he llegado con:

int main(int nArgs, char ** vArgs) 
{ 
    vector<int> *v = new vector<int>(10); 
    v->at(2); //Retrieve using pointer to member 
    v->operator[](2); //Retrieve using pointer to operator member 
    v->size(); //Retrieve size 
    vector<int> &vr = *v; //Create a reference 
    vr[2]; //Normal access through reference 
    delete &vr; //Delete the reference. You could do the same with 
       //a pointer (but not both!) 
} 

Answer 2

Hay muchas soluciones. Por ejemplo, puede usar el método at().

* Supuse que usted busca un operador equivalente al [].

Answer 3

acceder a ella como cualquier otro valor del puntero:

std::vector<int>* v = new std::vector<int>(); 

v->push_back(0); 
v->push_back(12); 
v->push_back(1); 

int twelve = v->at(1); 
int one = (*v)[2]; 

// iterate it 
for(std::vector<int>::const_iterator cit = v->begin(), e = v->end; 
    cit != e; ++cit) 
{ 
    int value = *cit; 
} 

// or, more perversely 
for(int x = 0; x < v->size(); ++x) 
{ 
    int value = (*v)[x]; 
} 

// Or -- with C++ 11 support 
for(auto i : *v) 
{ 
    int value = i; 
} 

Answer 4

vector<int> v; 
v.push_back(906); 
vector<int> * p = &v; 
cout << (*p)[0] << endl; 

Answer 5

Se puede acceder a los métodos de iterador directamente:

std::vector<int> *intVec; 
std::vector<int>::iterator it; 

for(it = intVec->begin(); it != intVec->end(); ++it) 
{ 
} 

Si desea que el operador de matriz de acceso, tendría para desmarcar el puntero. Por ejemplo:

std::vector<int> *intVec; 

int val = (*intVec)[0]; 

Answer 6

La forma más fácil utilizarlo como matriz es utilizar vector::data() miembro.

Answer 7

¿Tiene un puntero a un vector porque así es como lo ha codificado? Es posible que desee reconsiderar esto y utilizar una referencia (posiblemente const). Por ejemplo:

#include <iostream> 
#include <vector> 

using namespace std; 

void foo(vector<int>* a) 
{ 
    cout << a->at(0) << a->at(1) << a->at(2) << endl; 
    // expected result is "123" 
} 

int main() 
{ 
    vector<int> a; 
    a.push_back(1); 
    a.push_back(2); 
    a.push_back(3); 

    foo(&a); 
} 

Si bien este es un programa válido, el estilo general C++ es pasar un vector por referencia en lugar de puntero. Esto será igual de eficiente, pero luego no tendrá que lidiar con punteros posiblemente nulos y asignación/limpieza de memoria, etc. Use una referencia constante si no va a modificar el vector, y una referencia no constante si necesitas hacer modificaciones

Aquí está la versión referencias del programa anterior:

#include <iostream> 
#include <vector> 

using namespace std; 

void foo(const vector<int>& a) 
{ 
    cout << a[0] << a[1] << a[2] << endl; 
    // expected result is "123" 
} 

int main() 
{ 
    vector<int> a; 
    a.push_back(1); 
    a.push_back(2); 
    a.push_back(3); 

    foo(a); 
} 

Como se puede ver, toda la información contenida dentro de un serán pasados ​​a la función foo, pero no va a copiar un valor completamente nuevo, ya que se pasa por referencia. Por lo tanto, es tan eficiente como pasar por un puntero, y puede usarlo como un valor normal en lugar de tener que descubrir cómo usarlo como puntero o tener que desreferenciarlo.