在函数调用结束后保留​​数组的内容。 (C++)

Question

假设我有以下代码。

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 个双打。我该怎么办？

Answer 1

使用向量。

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

---

现在，bar 和 foo 还是一样的 指针，但那里发生了变化 完全。

因为foo是在函数的栈上分配的，所以当函数返回时它会被释放。所以，bar 实际上没有指向任何地方！

Answer 2

通常您会将预先分配的内存传递给函数：

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。他们很好 =) 我不再使用数组了。

Answer 3

使用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;

Answer 4

使用new 分配不在函数范围内的内存。

完成后不要忘记delete[]内存。

Answer 5

您可以在堆上分配结果，或者更好的是，使用 std::vector。

Answer 6

如果您总是返回固定数量的元素并愿意使用 TR1 扩展（或 Boost），我会选择 std::tr1::tuple 而不是 vector 或数组。它是一个模板类，因此您需要按照以下方式对它进行 typedef：

typedef std::tr1::tuple<double, double, double, double, double, double> six_tuple;

使用 make_tuple() 和适当数量（和类型）的参数来创建函数返回的元组，并使用模板化的 get<N>() 函数访问其内容，例如：

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() 的参数数量和类型，如果您尝试分配错误类型的元组，则会引发错误。

我更喜欢这个，而不是自己管理内存，但你的里程可能会有所不同。