Hoe toegang krijgen tot de inhoud van een vector van een pointer naar de vector in C++?

Ik heb een aanwijzer naar een vector. Hoe kan ik nu de inhoud van de vector lezen via de aanwijzer?

Antwoord 1, autoriteit 100%

Er zijn veel oplossingen, hier zijn er een paar die ik heb bedacht:

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

Antwoord 2, autoriteit 24%

Toegang zoals elke andere aanwijzerwaarde:

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

Antwoord 3, autoriteit 19%

Heb je een aanwijzer naar een vector omdat je die zo hebt gecodeerd? Misschien wilt u dit heroverwegen en een (eventueel const) referentie gebruiken. Bijvoorbeeld:

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

Hoewel dit een geldig programma is, is de algemene C++-stijl om een ​​vector door te geven als referentie in plaats van met een aanwijzer. Dit zal net zo efficiënt zijn, maar dan heb je geen te maken met mogelijke null-pointers en geheugentoewijzing/opruiming, enz. Gebruik een const-referentie als je de vector niet gaat wijzigen, en een non-const-referentie als u moet wel wijzigingen aanbrengen.

Hier is de referentieversie van het bovenstaande programma:

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

Zoals je kunt zien, wordt alle informatie in a doorgegeven aan de functie foo, maar het kopieert geen geheel nieuwe waarde, omdat het wordt doorgegeven door middel van referentie. Het is daarom net zo efficiënt als het doorgeven van een aanwijzer, en u kunt het als een normale waarde gebruiken in plaats van dat u moet uitzoeken hoe u het als een aanwijzer moet gebruiken of dat u de verwijzing moet verwijderen.

Antwoord 4, autoriteit 10%

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

Antwoord 5, autoriteit 6%

Je hebt rechtstreeks toegang tot de iteratormethoden:

std::vector<int> *intVec;
std::vector<int>::iterator it;
for( it = intVec->begin(); it != intVec->end(); ++it )
{
}

Als u de array-access-operator wilt, moet u de verwijzing naar de aanwijzer verwijderen. Bijvoorbeeld:

std::vector<int> *intVec;
int val = (*intVec)[0];

Antwoord 6, autoriteit 2%

Er zijn veel oplossingen. U kunt bijvoorbeeld de methode at()gebruiken.

*Ik ging ervan uit dat je een zoekwoord bent voor de operator [].

Antwoord 7

vector <int> numbers {10,20,30,40};
vector <int> *ptr {nullptr};
ptr = &numbers;
for(auto num: *ptr){
 cout << num << endl;
}
cout << (*ptr).at(2) << endl; // 20
cout << "-------" << endl;
cout << ptr -> at(2) << endl; // 20

Antwoord 8

De eenvoudigste manier om het als array te gebruiken, is door het vector::data()-lid te gebruiken.