C ++用数字填充数组，然后返回指向它的指针

Question

Ive been faced with a problem recently that I can't think of a good way to solve. I'm using a case structure to attempt to set attributes to a "character" that will be passed to an object constructor.

Example:

//note this is inside a function with a return type of int*
int selection;
cin >> selection;
int * iPtr;

switch(selection){

case 1:{
     int anArray[6] = {8,5,2,4,250,100} // str, dex, int, luck, hp, mp
     iPtr = anArray;
     return iPtr;
}

//more cases and such below

The issue that I'm having is that when I return my pointer it seems to be filled with a good amount of junk, rather than the information, rather than the information that I would be expecting it to hold. Is that because the array gets destroyed at the end of the scope? If so what should I do to make this work out how I'm hoping for it to (getting a pointer with the values that I want).

Thanks!

Answer 1

Yes - anArray is declared on the stack. When the function exits, its stack frame is reclaimed, so it's no longer valid to refer to that memory. If you want the array to persist, allocate it on the heap instead:

int* anArray = new int[6]; // and initialize
return anArray;

Just remember to clean it up later at some point with the corresonding delete[] .

EDIT

You should prefer to use something that automatically manages resources for you, like in Praetorian's answer, so that you don't accidentally leak memory.

Answer 2

Yes, the array you've declared is indeed local to the function and no longer exists once the function exits. You can dynamically allocate an array using new and then have the caller delete[] the memory (but don't do this!), or modify your function to return an std::unique_ptr instead of a raw pointer.

unique_ptr<int[]> anArray (new int[6]);
// do initialization
return anArray;

Now, the caller doesn't have to worry about freeing memory allocated by the function.

EDIT:

There are a couple of different ways to perform initialization of the unique_ptr .

anArray[0] = 8;
anArray[1] = 5;
// etc ...

OR

int init[6] = {8,5,2,4,250,100};
std::copy( &init[0], &init[0] + 6, &anArray[0] );

Answer 3

Yes, it's because the local array is overwritten as the program runs. You can either declare the array static in the method (which would be a good idea for a fixed array like this), declare it at global scope, or allocate an array with new to return. The last alternative gives you the opportunity to have a different array returned for each call, but remember to deallocate the arrays after use.

Answer 4

In C++, the best answer is not to return a pointer . Instead, use a proper object instead of a C array or manually allocated memory and return this object:

std::vector<int> f() {
    std::vector<int> array;
    // fill array

    return array;
}

Using new int[x] (or whatever) is really, really deprecated in modern C++ code and is only deemed acceptable under very special circumstances. If you use it in normal code, this is a very obvious place for improvement. The same goes for other uses of manually managed memory. The whole strength of C++ lies in the fact that you don't have to manage your own memory, thus avoiding a multitude of hard to track bugs.

Answer 5

Yes, it is because the array you created is created on the stack, and when you return, the part of the stack that you were at is overwritten (presumably by a debug process).

To avoid this, you would write

int* anArray = new int[6];
// fill the array
return anArray;

In this case, you will also have to delete the returned result when you are finished with it, such as in

int* dataArray = getTheArray();
// Use the dataArray
delete [] dataArray;

Answer 6

Allocate array on the heap

int* anArray = new int[6];

You will have to delete it manually:

delete[] iPtr;