3

我找到了这个解决方案，但也许有更好的解决方案，你怎么看？

class A
{
        #A self-reference
        private $_a;
        #Construcotr makes a self-reference
        public function __construct()
        {
                $this->_a = $this;
        }
        #Some other functions
        public function hello()
        {
                echo 'Hello, world!' . PHP_EOL;
        }
        #Function to destruct just this object, not its parent
        public function myDestruct()
        {
                unset($this->_a);
                var_dump($this);
        }
}

class AProxy
{
        #The proxied object
        public $_a;
        #The constructor has to be rewritten
        public function __construct()
        {
                $this->_a = new A();
        }
        #The destructor
        public function __destruct()
        {
                $this->_a->myDestruct();
                unset($this->_a);
                var_dump($this);
        }
        #Some other functions
        public function __call($fct, $args)
        {
                call_user_func(array($this->_a, $fct), $args);
        }
}

echo 'START' . PHP_EOL;
#Use class AProxy instead of class A
$a = new AProxy();

$a->hello();

unset($a);

#Otherwize you need to trigger the garbage collector yourself
echo 'COLLECT' . PHP_EOL;
gc_collect_cycles();

echo 'END' . PHP_EOL;

如果我按原样使用 A 类，则取消设置不起作用，因为 A 在其属性之一中具有自引用。

在这种情况下，我需要手动调用垃圾收集器。

我找到的解决方案是使用一个名为 AProxy 的代理类，它在 A 中调用一个名为 myDestructor 的特殊函数，该函数仅破坏 A 类而不破坏其父类。

然后 AProxy 的析构函数在 A 的实例上调用 myDestructor。

为了使 AProxy 类似于 A 类，我重新实现了 __call 函数（属性的 setter 和 getter 也可能被重载）。

你有比这更好的解决方案吗？

4

0 回答 0