3

The code below illustrates the destruct() being called twice. I'd like to know why?

class A {
    function hi(){ echo 'hi'; }
    function __destruct(){
        echo 'destroy';
    }
}
class B{
    public $this_ = '';
    function __construct(){
        $this->this_ = new A;
    }
    function __call($method, $params) {
          return call_user_func_array(array($this->this_, $method), $params);
    }
}

$b = new B;
$b->__destruct();

output:

destroydestroy

EDIT

Both zneak and TomcatExodus is correct. If I simply:

[..code..]
$b = new B;
$b->__destruct();
print 'end of script';

The output will show:

destroyend of scriptdestroy
Improve this question
4
  • Hmm I didn't notice that B doesn't extend A. I think it might be calling destructors of every object contained within the instance you invoke it on. Commented Mar 5, 2011 at 3:10
  • @TomcatExodus: It's not a typo. OP says calling destruct on B is invoking it on the A property. Commented Mar 5, 2011 at 3:13
  • @BoltClock; Yea, realized and deleted comment. Just tested, Since class B creates an instance of class A, and B also uses __call() to route to the self contained A object, a __destruct() call on B gets routed to the self contained instance of A. At script termination, all objects leave memory, and the A object fires destruct again. Our answers were still right I believe, just with a twist on the situation. Commented Mar 5, 2011 at 3:17
  • 1
    @TomcatExodus: Darn magic methods! :) Commented Mar 5, 2011 at 3:18

4 Answers 4

Reset to default
14

Invoking destruct doesn't destroy the object. You call it with __destruct() the first time, then when the PHP script terminates, it calls it again at cleanup.

If you're looking to destroy the object prior to script termination, unset() it. You should see only a single destruct call made.

Specifically, your class B creates a self contained instance of class A. Since B also routes method calls via __call() to the A object, that's why a __destruct() call on B is calling __destruct() on A; B has no destructor defined and passes the call up.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Yea, I missed a few but added to the comment, I'll add to answer also.
@BoltClock; Thankyou! Not at all, precision is necessary :)
10

Since B has no __destruct method, the __call method is called instead (you can verify this by adding something like echo "calling $method" to your __call method), and then it is then forwarded to your A object.

However, calling __destruct doesn't destroy the object: it just calls the cleanup code that should be associated to its destruction. So once you get at the end of your script, when the A object is actually destroyed, its __destruct method is called again.

If you want to delete your B object, use unset($b).

Improve this answer

4 Comments

I don't know which one to officially say is the right answer from you both, TomcatExodus and zneak, since you both are right. After a simple test of printing something after __destruct() was called showed that the destruction of the class after page execution calls the __destruct() again resulting in a print out of "destructend of scriptdestruct".
@Xiquid Then give TomcatExodus the right answer mark, I answered a few minutes after him and he needs more the reputation than I do.
one more question though, you both say unset($b), however when reading about that, unset() does not release resources, that it's best to call __destruct() then unset(), this is probably due a little bit of my confusion: php.net/manual/en/function.unset.php#98692
@Xiquid Pretty sure this is wrong. You can test yourself with a simple snippet that creates then unset an object. Put an echo statement in the destructor and another echo statement after the unset call, and you'll see that __destruct is called during the unset call (on the contrary of what the guy says). The only case in which it will not happen is if there are still other references left to the object (e.g. $a = new A; $b = $a; unset($a); will not call the destructor because $b still references the object).
2

Calling the destructor manually is one of the worst ideas, especially when dealing with others' code. An object has a logic that starts on construct, goes through methods and ends on destruct. On destruct, the object might require some cleanup and variables might be invalidated. When destruct is called internally, as a result of a succeeded unset($Object), the object is no longer available. When you do it manually, the object is still within reach but has no internal variable support if it did some cleanup itself.

Now think how it would be if you called a method on the object that relies on data that you have invalidated prematurely after invoking destruct manually. It breaks the entire logic! So always unset() and let PHP do its thing.

Manual destruct (placement delete :)) is awesome in C++ if you know what you're doing, especially combined with placement new. But you have to guard yourself throughout the entire implementation and make sure you actually have the data when a method is called. And you have to guard yourself in the destruct if you manage memory manually, not to delete pointers TWICE and crash in the process.

Memory management is so cool in C++! I hate GC (garbage collectors) :)

--- RANT OVER ---

Improve this answer

1 Comment

Hi @CodeAngry! Thanks for the rant. :) Yep I do understand that. There is no point in calling __destruct(). I always unset my objects internally when I'm working with class wrappers. Thanks for the memory management tip in C++.
0

You are invoking a destructor manually; but that does not mean that you are deleting the object. You are just invoking a method, and that method is just like any other.

The call to $b->__destruct() calls $b->this_'s destructor, because $b has no explicit destructor method.

When the script finalizes, the Zend Engine calls all instantiated objects their destructors and then performs a routine cleanup, which involves calling the contained objects' destructors, i.e., after destroying $b, $b->this_ has to be cleared and, to do that, the Engine calls its constructor automatically.

Note that the second call is not due to the destruction of $b but due to the destruction of the A instance.

There is NO handicap in destroying an object manually, and it does free its resources (unless the object is being shared, and then the GC won't destroy it unless there are no more references to it; in PHP there are no weak-references).

Example of a GC working: http://codepad.org/7JDBoOKY

The objects gets destructed before the code finalizing. If it wasn't then the order of the output would have been inverted.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.