Returning integer array from function with no arguments [duplicate]

Answer 1

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

It should propabally work now :)

Answer 2

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 3

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 4

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 5

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.

Answer 6

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.