Returning integer array from function with no arguments

Question

Possible Duplicate:
Returning local data from functions in C and C++ via pointer

I need to create a function with no arguments that returns an array

I get the error: "warning: function returns address of local variable"

my code has been simplified for ease of reading

int * getNums()
{
    int nums[8];
    nums = {1,2,3,4,5,6,7,8};
    return nums;
}

I am led understand that when the function ends the pointer is lost, but will the array still be sent? If not, what is a good way to return this integer array with no arguments in the function call?

Appreciate the help in advance!

Cheers

Answer 1

No, the array will not be "sent". You need to do one of these:

• create the array dynamically using new
• create the array statically
• pass the array into the function as a pointer
• use std::vector

In most cases, the last is the preferred solution.

Answer 2

Pretend you don't know what C-arrays are and join the world of modern C++:

#include <array>
std::array<int, 8> getNums()
{
    std::array<int, 8> ret = {{ 1, 2, 3, 4, 5, 6, 7, 8 }};
    return ret;
}

If your compiler is too old to provide a std:: or std::tr1:: implementation of array<>, consider using boost::array<> instead. Or, consider using std::vector<> either way.

Answer 3

I am led understand that when the function ends the pointer is lost, but will the array still be sent?

The behavior is undefined.

what is a good way to return this integer array with no arguments in the function call?

int nums[8];

num is local variable which resides on stack. You cannot return the reference of a local variable. Instead alloc nums with operator new and remember to delete[] it.

int* getNums()
{
     int *nums = new int[8] ;
     // .....

     return nums ;
}

// You should deallocate the resources nums acquired through delete[] later,
// else memory leak prevails.

Answer 4

Whenever a function exits all the local variables created within that function get trashed.
You are creating an array local to the function and then returning a pointer to the array. The returned pointer will point to an memory location which is already reclaimed by the OS. So it wont work for you.
Instead of Arrays, You should use vectors, since it is C++

Answer 5

You can't return a simple array in C++. Try

int *getNums()
{
    int *nums = new int[8];
    ...
    return nums;
}

Now nums is a pointer to a heap array which will live on after getNums returns.

Answer 6

int* getNums()
{
    static int nums[8];
    nums = {1,2,3,4,5,6,7,8};
    return nums;
}

It should propabally work now :)

Answer 7

Your array is a regular stack-based local variable. That means that it disappears when you return from the function and returning a pointer to it does not work. You have to make the array live longer, which can be done by turning it into a static variable or allocating it on the heap:

int *getArray {
    static int foo[] = {…};
    return foo;
}

int *getArray {
    int foo[] = calloc(numberOfItems, sizeof(int));
    foo = …;
    return foo;
}

Both solutions have implications that you should understand before you use one. Namely, the static allocation (first option) is mainly a curiosity nowaydays, since it creates a sort of a global variable and causes more problems than it solves. The heap-allocated array is quite common, but it’s more customary to pass the pointer to fill using an argument to make the interface more explicit. In every case the caller is responsible for freeing the allocated memory later.

And, as others note, there are even better solutions specific to C++, if you don’t insist on using a plain C array.