Re: unset and circular references

Quoting Abu Warez <abuwarez@yahoo.com>:

Hi, I'm using php 5.2.1 on an Ubuntu machine. I have the following class diagram (observer pattern):

+---------+             +---------+             +-------------+

| class A |<#>--------->| class B |< >--------->| interface C |

|         |             +---------+             |             |
|         |-----------------------------------|>|             |
+---------+                                     +-------------+

in my case class A, the creator of class B, is also the class to observe for class B. The following code implements the above diagram: <?php interface C { } class B {

        var $m_ObsC;

        public function __construct( C $p_ObsC )
        {
                $this->m_ObsC = $p_ObsC;
        }

        public function __destruct()
        {
                echo "B::destruct called <br>";
        }

} class A implements C {

        var $m_b;

        public function __construct()
        {
                $this->m_b = new B( $this );
        }

        public function __destruct()
        {
                echo "A::destruct called <br>";
        }

} $a = new A(); unset( $a ); echo "<br>-----end-of-script----<br>"; ?> the output of the above code is: -----end-of-script---- A::destruct called B::destruct called So actually the memory used by object $a is freed only after the script ends and NOT when unset was called. Now this is a big problem for me, because i need to free the memory when I call unset and not after the script ends else php runs out of memory in my real application. Object $a is not referenced by any other object. I also tried with: $this->m_b = new B( &$this ); but the result is the same. Any clue how to determine php tho free the memory when unset is called and not after the script ends? Thanks, Abu

I think this happens because there is still a reference to the B object. According to the manual : The destructor method will be called as soon as all references to a particular object are removed or when the object is explicitly destroyed or in any order in shutdown sequence. So as long as A has a reference to B the __destructor will not be called.