Pointeur vers un vecteur

Question

J'ai un pointeur sur un vecteur. Maintenant, comment puis-je lire le contenu du vecteur à l'aide du pointeur? Je sais que c'est une question fondamentale, mais je suis incapable de trouver une réponse pour la même chose. (C++)

Answer 1

Il existe de nombreuses solutions, voici quelques-unes que je suis venu avec:

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

Il y a beaucoup de solutions. Par exemple, vous pouvez utiliser la méthode at().

* J'ai supposé que vous recherchez un opérateur équivalent à [].

Answer 3

Accès comme toute autre valeur de pointeur:

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

Vous pouvez accéder aux méthodes iterator directement:

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

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

Si vous voulez que l'opérateur d'accès au tableau, vous auriez pour dé-référencer le pointeur. Par exemple:

std::vector<int> *intVec; 

int val = (*intVec)[0]; 

Answer 6

La meilleure façon d'utiliser comme tableau est vector::data() utiliser membre.

Answer 7

Avez-vous un pointeur sur un vecteur parce que c'est comme cela que vous l'avez codé? Vous pouvez reconsidérer cela et utiliser une référence (éventuellement const). Par exemple:

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

Bien que ce soit un programme valide, le style général C++ est de passer un vecteur par référence plutôt que par le pointeur. Ce sera tout aussi efficace, mais vous n'aurez pas à faire avec des pointeurs null et allocation de mémoire/nettoyage, etc. Utilisez une référence const si vous ne voulez pas modifier le vecteur, et une référence non-const si vous avez besoin de faire des modifications.

est ici la version références du programme ci-dessus:

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

Comme vous pouvez le voir, toutes les informations contenues dans un sera transmis à la fonction foo, mais il ne sera pas copier une toute nouvelle valeur, puisqu'il est passé par référence. Il est donc aussi efficace que de passer par un pointeur, et vous pouvez l'utiliser comme une valeur normale plutôt que d'avoir à comprendre comment l'utiliser comme pointeur ou devoir le déréférencer.