return function pointer getting crushed??

I have a function that produces an array result. I return a pointer to that result. I am finding that the pointer / array looks as expected at a breakpoint right after the function returns but a few lines down the code the array values are getting crushed. I am learning that the stack gets reclaimed and yes this can and will happen. My question is what can I do right after the function returns to claim the array in main and not have it change on me? I would like to not modify the function (ie leave the pointer to the returned array) if possible.

Thanks

Declare the array in the caller and pass a pointer to the array as an argument when calling the function. It is also wise to have a parameter for the size of the array.

Alternatively, you can use dynamic memory allocation in the function, then the caller has the responsibility to call free when done.

Yet another possibility is to declare the array static within the function, but that has its own pitfalls.

This NEVER works, can never work.

Code:

---

int *foo ( ) {
  int array[10];
  // do stuff
  return array;
}

---

Fix 1

Code:

---

int *foo ( ) {
  static int array[10];
  // do stuff
  return array;
}

---

The array persists past the end of the function call, but the function is not re-entrant.

It isn't thread safe (at all), and you have to be careful to make use of the result before calling the function again.

Code:

---

int *a = foo();
int *b = foo();  // you just trashed a

---

Fix 2

Code:

---

int *foo (int *array, int size) {
  // do stuff
  return array;
}

---

This is the only way to go really.
It gives the caller the greatest flexibility to decide what to use to store the data, whether it be a local array or some malloc'ed pointer.

I think I solved it....I just declared the return variable as static within the function and now the results are retained....Is there any reason why this method can't be used?

Laserlight: What are the pitfalls of using static as you alluded to this in your post?

forget it as I just saw Salem's comments on this....

I do believe it is safe as I immediately act on the results and use them before the function gets called again....This is all occurring on an embedded processor with a well defined function and purpose....

Thank you both for your replies

> I do believe it is safe as I immediately act on the results and use them before the function gets called again
Well....

> This is all occurring on an embedded processor with a well defined function and purpose....
You'd have to be running with ALL interrupts disabled, but that's one hell of an assumption.

Quote:

---

Originally Posted by Salem

> This is all occurring on an embedded processor with a well defined function and purpose....
You'd have to be running with ALL interrupts disabled, but that's one hell of an assumption.

---

Only if the function is also called from an interrupt handler. If the function isn't used by any interrupt handler (only by the main code), there's no need to disable interrupts.

Oh but there is.

Just having an interrupt happen will trash the contents of the very stack currently balanced on a knife edge of calamity.

Quote:

---

Originally Posted by Salem

Just having an interrupt happen will trash the contents of the very stack currently balanced on a knife edge of calamity.

---

Well yes of course, but OP already decided to use "static" which avoids that problem altogether.