Thread: [?] what's the doese param in destroy(class* &i) mean?

The &, in this case, means that you are passing by reference, which allows the function, destroy in this case, to modify the value of i.

However, I'm a bit suspect to your code - I don't think either should work the way they are, as you are deleting a static array - it may be that it's not actually working in either case, but it APPEARS to work in the first case due to some spurios side-effect. You should NEVER delete something that wasn't created by new.

--
Mats

Code:

class arr[3] = .....  .
./*construction for each element*/
destroy(arr[0]);

To do this, you'd need to have an array of pointers allocated with new:

Code:

Class* arr[3] = { new Class, new Class, new Class };

Code:

void destroy(class* i)
{
      delete i;
      i = NULL;
}

Here setting i to NULL serves no purpose, since the pointer i is a local variable and goes out of scope anyway (the caller's pointer will keep the same value).

Code:

void destroy(class* &i)

Here the pointer is passed by reference, hence changes to i in destroy will affect the value of the pointer passed in (the caller's pointer will be NULL after this call).

thanks.
sorry for not clear about the code. the class arr[3] is created by "new" .

arry is a an array of pointer to the Class;
arr[1] is the pointer to Class;which is initialized by new Class(.....);

so doesn't "delete arr[1]" delete the Class object holding by arr[1]?

Would you be able to post the ACTUAL code, as the devil is in the detail here.

--
Mats

Originally Posted by martinuk

Both compiled ok, but the Ver 1 has run time error.

Ah, but the error is probably produced by code that you did not show.

The problem is that since destoryButton takes its argument by value, b = NULL merely acts on the local copy of the pointer passed to the function. Consequently, in the caller, the pointer continues to point to the destroyed Button object. If later code performs a check for a null pointer before using the object pointed to, the check will conclude that the pointer is not a null pointer, leading to the use of the destroyed object, resulting in undefined behaviour that can be manifested in a run time error.

The solution is to change destoryButton to take its argument by reference. Actually, there's more: the check for NULL is unnecessary because it is safe to use delete on a null pointer. If you find yourself frequently writing code that uses delete followed by setting the pointer to a null pointer constant, consider writing a function template to do it for you, as described by Stroutrup's answer to Why doesn't delete zero out its operand?

You would then write:

Code:

void MainWindow::destoryButton(Button*& b)
{
    destroy(b);
}

Here is good advice to avoid confusion. Everything in C and C++ is passed by value. Everything. That means the value in the variable you pass is copied, a new variable is created, a local variable to the function, and is assigned the value from the variable you copy.
So if a new copy is made, how can we modify a variable in another function?
The easiest way, in C++, is simply to declare it a reference. Simplistically, we might say that the local "variable" in the function is an alias for the original variable that you pass, so it is modified instead of a local copy.

I hope that explains what happens and why.