C++ 在另一个函数中使用函数内声明的向量 #包括 #包括 使用名称空间std； 无效em（向量*pv）； int main（） { 向量*pv=NULL； em（pv）； printf（“%d%d”，（*pv）[0]，（*pv）[1]）；//错误！ } 无效em（向量*pv） { 向量V； pv=&V； V.推回（1）； V.推回（2）； printf（“%d%d\n”，V[0]，V[1]）； //12好的！ }

我知道向量是动态赋值。 但是，当函数结束时，内存似乎被释放。 我想使用一个指针来使用在另一个函数中的函数内部声明的向量。

---

我该怎么办？

您可以在函数中返回一个向量。在C++11中，它移动值而不是复制值，因此按值返回不是问题

#include <iostream>
#include <vector>

using namespace std;

void em(vector<int>* pv );

int main()
{
    vector<int>* pv = NULL;
    em(pv);
    printf("%d %d", (*pv)[0], (*pv)[1]); // Error!

}

void em(vector<int>* pv)
{
    vector<int> V;
    pv = &V;

    V.push_back(1);
    V.push_back(2);
    printf("%d %d\n", V[0], V[1]);
    // 1 2  OK!

}

intmain（）
{
向量pv=em（）；
printf（“%d%d”，pv[0]，pv[1]）；
}
向量em（）
{
向量V；
...
返回V；
}

或者通过引用

int main()
{
    vector<int> pv = em();
    printf("%d %d", pv[0], pv[1]);
}

vector<int> em()
{
    vector<int> V;
    ...
    return V;
}

intmain（）
{
向量pv；
em（pv）；
printf（“%d%d”，pv[0]，pv[1]）；
}
无效em（向量和V）
{
V.推（1）；
V.推（2）；
...
}

您只需在函数中返回一个向量即可。在C++11中，它移动值而不是复制值，因此按值返回不是问题

#include <iostream>
#include <vector>

using namespace std;

void em(vector<int>* pv );

int main()
{
    vector<int>* pv = NULL;
    em(pv);
    printf("%d %d", (*pv)[0], (*pv)[1]); // Error!

}

void em(vector<int>* pv)
{
    vector<int> V;
    pv = &V;

    V.push_back(1);
    V.push_back(2);
    printf("%d %d\n", V[0], V[1]);
    // 1 2  OK!

}

intmain（）
{
向量pv=em（）；
printf（“%d%d”，pv[0]，pv[1]）；
}
向量em（）
{
向量V；
...
返回V；
}

或者通过引用

int main()
{
    vector<int> pv = em();
    printf("%d %d", pv[0], pv[1]);
}

vector<int> em()
{
    vector<int> V;
    ...
    return V;
}

intmain（）
{
向量pv；
em（pv）；
printf（“%d%d”，pv[0]，pv[1]）；
}
无效em（向量和V）
{
V.推（1）；
V.推（2）；
...
}

在堆栈上创建的变量的持续时间仅与函数的持续时间相同。当em返回时，向量后面的内存被释放

为了有一个持续时间更长的函数，您需要返回一个完整的对象，或者从堆中分配向量

int main()
{
    vector<int> pv;
    em(pv);
    printf("%d %d", pv[0], pv[1]);
}

void em(vector<int> &V)
{
    V.push(1);
    V.push(2);
    ...
}

向量em（） { 向量V； pv=&V； V.推回（1）； V.推回（2）； printf（“%d%d\n”，V[0]，V[1]）； //12好的！ 返回V； } 或

void em（向量*pv）
{
pv=新向量（）；
向量&V=*pv；
V.推回（1）；
V.推回（2）；
printf（“%d%d\n”，V[0]，V[1]）；
//12好的！
//主要需要删除pv
}

在堆栈上创建的变量的持续时间仅与函数的持续时间相同。当em返回时，向量后面的内存被释放

为了有一个持续时间更长的函数，您需要返回一个完整的对象，或者从堆中分配向量

int main()
{
    vector<int> pv;
    em(pv);
    printf("%d %d", pv[0], pv[1]);
}

void em(vector<int> &V)
{
    V.push(1);
    V.push(2);
    ...
}

向量em（） { 向量V； pv=&V； V.推回（1）； V.推回（2）； printf（“%d%d\n”，V[0]，V[1]）； //12好的！ 返回V； } 或

void em（向量*pv）
{
pv=新向量（）；
向量&V=*pv；
V.推回（1）；
V.推回（2）；
printf（“%d%d\n”，V[0]，V[1]）；
//12好的！
//主要需要删除pv
}

#包括
#包括
使用名称空间std；
向量*em（）；
void P（向量*）；
int main（）
{
向量*pv=NULL；
pv=em（）；
printf（“第二个：%d%d\n”，（*pv）[0]，（*pv）[1]）；
P（pv）；
}
向量*em（）
{
//向量V；
向量*pV=新向量；
（*pV）。推回（1）；
（*pV）。推回（2）；
printf（“第一个：%d%d\n”，（*pV）[0]，（*pV）[1]）；
//12好的！
返回pV；
}
空隙P（向量*pv）
{
printf（“第三个：%d%d\n”，（*pv）[0]，（*pv）[1]）；
}

这很有效

-------结果------

第一：12

第二名：12

第三：12包括 #包括 使用名称空间std； 向量*em（）； void P（向量*）； int main（） { 向量*pv=NULL； pv=em（）； printf（“第二个：%d%d\n”，（*pv）[0]，（*pv）[1]）； P（pv）； } 向量*em（） { //向量V； 向量*pV=新向量； （*pV）。推回（1）； （*pV）。推回（2）； printf（“第一个：%d%d\n”，（*pV）[0]，（*pV）[1]）； //12好的！ 返回pV； } 空隙P（向量*pv） { printf（“第三个：%d%d\n”，（*pv）[0]，（*pv）[1]）； } 这很有效

-------结果------

第一：12

第二名：12

---

第三：12

函数em的变量向量v是临时的，当函数em返回时，变量向量v的生命将结束，内存将删除。您可以传递对em函数的引用，也可以传递em中的新指针。 如果您不想传递指针，可以阅读下面的代码以供参考

#include <iostream>
#include <vector>

using namespace std;

vector<int>* em( );
void P(vector<int>*);

int main()
{
    vector<int>* pv = NULL;
    pv = em();

    printf("Second : %d %d\n", (*pv)[0], (*pv)[1]); 

    P(pv);

}

vector<int>* em()
{
    //vector<int> V;
    vector<int>* pV = new vector < int > ;


    (*pV).push_back(1);
    (*pV).push_back(2);
    printf("First: %d %d\n", (*pV)[0], (*pV)[1]);
    // 1 2  OK!
    return pV;

}

void P(vector<int>* pv)
{
    printf("Third : %d %d \n", (*pv)[0], (*pv)[1]);
}

#包括
#包括
#包括
使用名称空间std；
无效em（向量*&pv）；
int main（）
{
向量*pv=NULL；
em（pv）；
printf（“%d%d”，（*pv）[0]，（*pv）[1]）；
删除pv；
pv=零；
}
无效em（向量*&pv）
{
向量*V=新向量；
pv=V；
V->推回（1）；
V->推回（2）；
printf（“%d%d\n”，V->at（0），V->at（1））；
//12好的！
}

函数em的变量向量v是临时的，当函数em返回时，变量向量v的寿命将结束，内存将删除。您可以传递对em函数的引用，也可以传递em中的新指针。 如果您不想传递指针，可以阅读下面的代码以供参考

#include <iostream>
#include <vector>

using namespace std;

vector<int>* em( );
void P(vector<int>*);

int main()
{
    vector<int>* pv = NULL;
    pv = em();

    printf("Second : %d %d\n", (*pv)[0], (*pv)[1]); 

    P(pv);

}

vector<int>* em()
{
    //vector<int> V;
    vector<int>* pV = new vector < int > ;


    (*pV).push_back(1);
    (*pV).push_back(2);
    printf("First: %d %d\n", (*pV)[0], (*pV)[1]);
    // 1 2  OK!
    return pV;

}

void P(vector<int>* pv)
{
    printf("Third : %d %d \n", (*pv)[0], (*pv)[1]);
}

#包括
#包括
#包括
使用名称空间std；
无效em（向量*&pv）；
int main（）
{
向量*pv=NULL；
em（pv）；
printf（“%d%d”，（*pv）[0]，（*pv）[1]）；
删除pv；
pv=零；
}
无效em（向量*&pv）
{
向量*V=新向量；
pv=V；
V->推回（1）；
V->推回（2）；
printf（“%d%d\n”，V->at（0），V->at（1））；
//12好的！
}

使用

std:：vector em（）

并返回向量。（N） RVO将删除看起来是副本的内容。或者将引用传递给em。我需要从函数a创建一个向量，并在B中使用该向量。因此我尝试使用指针进行通信。@StackQ您不需要使用指针，只需返回向量本身，如果您担心性能，那么打开编译器优化并查看输出程序集，以确保对象未被复制。顺便说一句，如果您愿意允许传递ptr，您有什么理由反对在

main

范围内创建向量而不是

em

？使用

std:：vector em（）

并返回向量。（N） RVO将删除什么外观