可以说我有以下代码。在函数调用结束后保持数组的内容。 （C++）
double *return_array(void) {
double foo[2];
foo[0] = 5;
foo[1] = 6;
cout << foo << endl;
cout << foo[0] << endl << foo[1] << endl;
return foo;
}
double *bar = return_array()
cout << bar << endl;
cout << bar[0] << endl << bar[1] << endl;
现在，bar和foo仍然是相同的指针，但是那里发生了什么变化。我怎样才能解决这个问题？基本上，我需要从一个函数传递6或9个双打。我该怎么办？
通常你会通过你的预分配内存入函数：
int barsize = 2;
double *bar = new double[barsize];
fill_array(bar, barsize);
cout << bar << endl;
cout << bar[0] << endl << bar[1] << endl;
delete [] bar;
void fill_array(double *foo, int foosize)
{
if (foosize < 2)
return;
foo[0] = 5;
foo[1] = 6;
cout << foo << endl;
cout << foo[0] << endl << foo[1] << endl;
}
我用的是......总是分配并在同一地点删除内存的规则。
或使用std :: vector。他们很好=）我再也不用阵列了。
使用new关键字在堆上分配，而不是堆栈内存：
double *return_array(void) {
double * foo = new double [2];
foo[0] = 5;
foo[1] = 6;
return foo;
}
然后调用该函数最终会当它与它使用delete做必须释放内存的代码：
double * foo = return_array();
// ...
delete [] foo;
使用new将未作用域的内存分配给函数。
不要忘记delete[]当你完成它的记忆。
您可以在堆上分配结果，或者更好的方法是使用std :: vector。
使用矢量。
std::vector<double> return_array(void) {
std::vector<double> foo;
foo.push_back(5);
foo.push_back(6);
cout << foo[0] << endl << foo[1] << endl;
return foo;
}
这是一个更好的办法，让你避免复制的载体：
void fillVector(std::vector<double>& vec)
{
vec.push_back(5);
vec.push_back(6);
}
int main()
{
std::vector<double> vec;
fillVector(vec);
}
现在，酒吧和Foo仍然是相同的 指针，但那儿有什么完全改变了 。
因为foo被分配在该函数的堆栈上，所以当函数返回时它被取消分配。所以，bar实际上是指向没有的地方！
如果您总是返回固定数量的元素并愿意使用TR1扩展（或Boost），那么我会使用std::tr1::tuple而不是vector或数组。这是一个模板类，所以你要的typedef它，沿着线：
typedef std::tr1::tuple<double, double, double, double, double, double> six_tuple;
使用make_tuple()用的参数来创建元组的函数返回相应数量（类型），并访问其内容与模板化的功能，例如：
six_tuple foo = std::tr1::make_tuple(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
std::cout << std::tr1::get<0>(foo) << std::endl; // prints '1.0'
编译器将在参数的数量和类型内省到make_tuple()，如果你想分配给排序元组的错误抛出异常。
我更喜欢这个，不得不自己管理内存，但是你的里程可能会有所不同。
除了下面的好回复之外，如果你有一个固定数量的值，你可能想用它们创建一个结构类，然后返回它。根据您的值的使用情况，可能会更容易阅读/处理使用g = foo [gravity]代替：g = foo.gravity – 2009-08-03 02:24:04