C++ 从指针到法向量的转换在main内部有效，但从函数返回时无效 intmain（） { 向量*v2，v3； 向量v； v、 推回（2）； v、 推回（1）； v、 推回（17）； v、 推回（6）； 向量v1； v1.向后推（v）； v2=v1.at（0）； v3=*v2； 对于（std:：vector:：迭代器i=v3.begin（）；i！=v3.end（）；++i） { cout

问题在于，函数返回的向量包含指向另一个本地定义的向量的指针。后者在函数末尾被销毁，因此外部向量中的指针悬空

vector<vector<int> *> func()
{
    vector<int> v;
    v.push_back(2);
    v.push_back(1);
    v.push_back(17);
    v.push_back(6);
    vector<vector<int> *> v1;
    v1.push_back(&v);
    return v1;
}
int main() 
{

    vector<int> *v2, v3;
    vector<vector<int> *> v1;
    v1 = func();
    v2 = v1.at(0);
    v3 = *v2;
    for (std::vector<int>::iterator i = v3.begin(); i != v3.end(); ++i)
    {
        cout<<*i<<endl;
    }
    return 0;
}

vector func（）
{
vector v；//此对象在函数末尾被销毁
v、 推回（2）；
v、 推回（1）；
v、 推回（17）；
v、 推回（6）；
向量v1；
v1.向后推（&v）；//危险指针&v将摆动
返回v1；
}

除非绝对必要，否则不要在向量内使用指针（即使在这种情况下，也更喜欢使用智能指针，因为它们跟踪所有权）。您可以简单地使用

向量或1D向量，并从1D映射到2D，反之亦然。后一个选项是首选选项，因为它保证所有元素都位于连续的内存区域中，因此缓存友好。
问题在于：

vector<vector<int> *> func()
{
    vector<int> v; // this object is destroyed at the end of the function
    v.push_back(2);
    v.push_back(1);
    v.push_back(17);
    v.push_back(6);
    vector<vector<int> *> v1;
    v1.push_back(&v); // DANGER DANGER the pointer &v will dangle
    return v1; 
}

v1[0]
中的指针将指向
v
，该指针不再存在，因为它已超出范围（
func
函数）并已被销毁。取消引用此指针是，因此您将获得BADALOC

此问题至少有两种解决方案。第一种是将
v1
声明为

v1 = func();

所以
v
的内容在
v
超出范围后不会被破坏。但是你不应该忘记在使用后手动删除它，否则你会出现内存泄漏。
@vsoftco-yup刚刚意识到，在我删除了我的评论之后。你为什么不使用
vector
？相关：是的，这很有意义。如果有答案，谢谢！@RaghavPandya有道理那么接受它（或者其他更好的答案）也是有道理的，这样其他人就可以看到问题得到了解决。谢谢，我明白了！
vector<int> v;
//...
v1.push_back(&v);
return v1;

v1 = func();

vector<vector<int>> v1;

vector<int> *v = new vector<int>;
v->push_back(2);
v->push_back(1);
v->push_back(17);
v->push_back(6);
vector<vector<int> *> v1;
v1.push_back(v);