Keeping the contents of an array after its function call ends. (C++)

Question

Lets say I have the following code.

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;

Now, bar and foo are still the same pointer but what was there has changed completely. How can I get around this? Basically, I need to pass 6 or 9 doubles from a function. What should I do?

Answer 1

Allocate the memory on the heap instead of the stack using the new keyword:

double *return_array(void) {
    double * foo = new double [2];
    foo[0] = 5;
    foo[1] = 6;
    return foo;
}

Then the code that calls the function will eventually have to free up the memory when it's done with it using delete:

double * foo = return_array();
// ...
delete [] foo;

Answer 2

Use new to allocate memory that isn't scoped to the function.

Don't forget to delete[] the memory when you're done with it.

Answer 3

You can allocate the result on the heap or, better yet, use std::vector.

Answer 4

Use a 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;
}

---

This is a better way, So you avoid copying the vector :

void fillVector(std::vector<double>& vec)
{
    vec.push_back(5);
    vec.push_back(6);
}

int main()
{
    std::vector<double> vec;

    fillVector(vec);
}

---

Now, bar and foo are still the same pointer but what was there has changed completely.

Because foo is allocated on the stack of the function, it gets deallocatd when the function returns. So, bar is actually pointing no where!

Answer 5

Typically you would pass in your pre-allocated memory into the function:

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

The rule I use is... always allocate and delete memory in the same spot.

Or use a std::vector. They're nice =) I never use arrays anymore.

Answer 6

If you're always returning a fixed number of elements and are willing to use TR1 extensions (or Boost), I'd go with std::tr1::tuple rather than vector or an array. It's a template class, so you'll want to typedef it, along the lines of:

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

Use make_tuple() with the appropriate number (and type) of arguments to create the tuple your function returns, and access its contents with the templated get<N>() function, e.g.:

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'

The compiler will introspect on the number and types of arguments to make_tuple(), and throw an error if you're trying to assign to the wrong sort of tuple.

I prefer this to having to manage the memory myself, but your mileage may vary.