Thread: Returning Arrays as pointers

Ok i have a function that returns an address to an array of ints which contains 4 items. How do I assign the contents of that address to a local variable.

The return statements is this return &date;

I want to copy the contents from this address into a new local array.


Thanks.

Originally Posted by itsme86

You could use the memcpy() function.

Something to look out for: If the array that you're returning is local to that function, then it is invalid before it gets returned to the calling function. You can't use the pointer in the calling function to get to the data unless you declare the array in the function as static.

Yah I forgot about that. I how would I pass that back then. The function accepts a string splits it up into integers and puts it into an array. Now, I need that array but I am not supposed to use static or global variables.

If inside the function, you use malloc() to allocate the necessary space for the array, then it is up to you to free that space, which means that you can safely return an address to that space from within your function. Something like this:

Code:

int* myFunction()
{
int *myArray = malloc(4 * sizeof(int));
return myArray;
}

int main()
{
int myArray[4];
int *p = myFunction();
memcpy(myArray, p, 4 * sizeof(int));
}

Can you declare the array you are supposed to return elsewhere in the program?
If so, you can also just pass a pointer to that array as an argument, work with it in your function, and return it back.

The standard way of doing this type of thing is to allocate the array outside the function, pass a pointer to the array to the function, and let the function write into it. This is also more efficient than what you're trying to do since it avoids the extra copy.

> The standard way
There is nothing standard about it. Don't confuse the standard way with the simplest way.

> There is nothing standard about it. Don't confuse the standard way with the simplest way.
Well, besides being simple, it's also as efficient as possible (since it avoids the extra copy) and makes it easier to match up malloc() and free(), since both are outside the function (unlike calling malloc() inside the function). It also allows more control over memory since one can allocate a large contiguous array outside and pass pointers to pieces of it to the function. So I think it's reasonable to call it "standard" in the sense that it's what most good programmers choose to use. I didn't mean that it was part of some formal standard.