在函数调用之后，以下c ++函数中的数组重新分配似乎已被忽略。

Question

void func(int* array)
{
    array=new int[5];
    for (int i=5; i>0; i--)
        array[5-i]=i;
}
int main()
{
    int array[5]= {1,2,3,4,5};
    func(array);
    cout<<array[1]<<endl;
}

I presume this has something to do with arrays being constant pointers. How exactly does c++ handle this code and what happens to the dynamic memory that is assigned within the function?

Answer 1

When you pass an array as argument to a function by value , it decays to the pointer to the first element, which then gets passed by value . So what you recieve in the function func is a copy of the address of the first element of the array. In the function, you simply change the address, which doesn't change the array in the main() function. Whatever you do to array in func() , is local to that function only. It is like this:

void f(int x)
{
     x= 100; //modifying the copy, not the variable in main()
}
int main()
{
     int value = 1000;
     f(x); //pass by value, means pass a copy!
}

In this case you're changing the value of x in f() . Likewise, in your case, you're changing the value of array . Since array is a pointer, you're making it pointing to a different location by allocating a new memory to it. Every change is local to the function.

Also note that since you allocate memory to the variable array , and don't deallocate it, your program leaks memory . In order to avoid that, you must write:

 delete [] array;

before returning from the function. Again, this delete wouldn't change array in main() .

By the way, if you want to change the element of the array in main() , then you should do this instead:

void func(int* array)
{
    //array=new int[5]; //just comment this
    for (int i=5; i>0; i--)
        array[5-i]=i; //now array points to the same memory 
                      //where main()'s array is in the memory.
}

Hope that helps.

Answer 2

Here's the problem:

array=new int[5];

This assignment means that the passed parameter will not be modified. After this assignment, array points to a newly allocated chunk of memory rather than to the array declared in main (and passed to func as an argument). What is modified is this newly allocated array -- and that's thrown away when the function returns. To make matters worse, you have a memory leak.