指向矢量的指针

Question

我有一个指向矢量的指针。现在，我怎样才能通过指针读取矢量的内容？我知道这是一个基本问题，但我无法找到同样的答案。（C++）

Answer 1

解决方法有很多，这里有几个我想出来的：

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

有很多解决方案。例如，您可以使用at()方法。

*我以为你找一个相当于[]的操作符。

Answer 3

访问它像任何其他指针值：

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

您可以访问迭代方法直接：

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

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

如果你想在数组访问运算符，你必须去引用指针。例如：

std::vector<int> *intVec; 

int val = (*intVec)[0]; 

Answer 6

最简单的方式来使用它作为阵列是使用vector::data()成员。

Answer 7

你有一个指向矢量的指针，因为这就是你编码的方式吗？您可能需要重新考虑这一点并使用（可能是const）引用。例如：

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

虽然这是一个有效的程序，但一般的C++风格是通过引用而不是指针传递向量。这将会同样有效，但是你不需要处理可能的空指针和内存分配/清理等。如果你不打算修改向量，那么使用一个const引用，并且如果是非const引用if你确实需要修改。

下面是引用版本以上程序：

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

正如你所看到的，包含内的信息将被传递给函数foo，但它不会复制一个完全新的价值，因为它是通过引用传递的。因此，它与传递指针一样高效，并且您可以将其用作正常值，而不必知道如何将其用作指针或不必将其解引用。