politically correct disposal of "newed" objects

bigpikture

Can someone please tell me "what is the proper way to dispose
of a new-ed object?"

if I .. $something = new someclassofmine();

how do I "delete" it when done?

I know that once the page is done being interpreted, that the garbage
collection is automatic, but for the case where I "new" up a boatload
of objects, I'd like to control the disposal. For example if an object
is newed within a loop which executes 1000 times, might be a good idea
to "delete" it each time as well.

Thanks in advance.

the_Igel

I think unset() is OK for it.

tomhath

It probably doesn't make an difference since the garbage collector knows when the reference count goes to zero.

Here's a suggestion to consider though, why not add a ReInitialize method to the class so you only new it once and reuse it 999 times?

bigpikture

tom, are you saying the "unset" suggest would not work?

I find it interesting that there does not seem to be a "delete"
convention for objects.

rrijnders

I hear you...

In pure OO programming, the purpose of a destructor method is not to delete the object, it is a function that is called when the object is deleted; in much the same way that the constructor is called when the object is new()'d. That is, if some code external to the object deletes the object, the destructor is called prior to the object's actual removal. This is useful for doing cleanup, recovery, messaging, etc upon the event that caused the object to be destroyed.

Even if this type of destructor is not possible or not deemed useful, it would be nice to be able to at least create my own destructor:

class myClass
{
   var $myProperty;

   // constructor
   function myClass()
   {
      // initialize some stuff
      $this->myProperty = "";
    }

   function destroy()
   {
      // do some cleanup
      // destroy myself
      unset($this);  // doesn't work!
   }

}

$myObject = New myClass;
$myObject->destroy();  // does not unset the object

...in fact, I can't even create a non-object function to delete an object:

function destroyObject(&$obj) 
{
   $obj->destroy(); // do some cleanup
   unset($obj);  // try to get rid of it
}

$myObject = new myClass;
destroyObject($myObject); // still doesn't destroy the object

I even tried GLOBALizing the object and using var-var's, but the only way I can accomplish some cleanup functionality and destroy an object is:

$myObject = new myClass;
$myObject->destroy();
unset($myObject); // only works here

Now, I have not done enough research to say there is a bug, but I would think that either of the first two methods should have worked. Especially the second with the object GLOBALized.

(sigh)

tomhath

I was probably wrong when I said it doesn't matter, unset must do something.

I'm not surprised you can't unset an object inside itself. Did you try calling the "destructor" as a class method with the object as a parameter (cheating a little, but should work).

rrijnders

Yeah, tried it that way too. No Joy.

killerbishop

You can emulate destructors by doing:

class myClass
{
      function myClass()
      {
           // Initialize class and register a shutdown function

       register_shutdown_function(array($this,'_myClass'));
  }

  function _myClass()
  {
      // Clean up data pools, connections, etc.
  }

}

Realize that PHP uses reference counting, so unless all instances are destroyed, the object will not be unset. BTW - make sure you instantiate the object using:

$instance =& new myClass();

Otherwise, the shutdown function will be registered to a copy, not the real instance!

rrijnders

That's fine for creating a destructor that executes when the page ends, but we were looking for a destructor that kicks in when the object is unset or when we want to execute it explicitly in the script.

driverdave

This page may explain a few things.

http://www.php.net/source.php?url=/zend2_example.php

http://www.php.net/ZEND_CHANGES.txt

PHP 4.3 should be nice.

the_Igel

Why one can't destroy an object inside a function (http://www.php.net/manual/en/function.unset.php):

If a globalized variable is unset() inside of a function, only the local variable is destroyed. The variable in the calling environment will retain the same value as before unset() was called.

If a variable that is PASSED BY REFERENCE is unset() inside of a function, only the local variable is destroyed. The variable in the calling environment will retain the same value as before unset() was called.

etc...

killerbishop

Well, that's true. But PHP won't support "real" destructors until the Zend 2 engine is released. At that point, unified constructors and destructors will exist as the special methods construct() and destruct().

bobthedog

Hi all.... I have been reading this thread with interest, since I believe the destructor is one of the biggest things currently missing from PHP's class functionality at present.

I have been playing with classes for quite a while now and consider myself to be failry competent (otherwise I don't think I would have my job anymore!), so here goes at my solution.

class test
{
	var $test_var = 'mine';

function test()
{
}

function destroy()
{
	$this = 0;
}
}

$obj = new test();
print($obj->test_var);
$obj->destroy();


if (is_object($obj))
	print("\nYes it is an Object\n");
else
	print("\nNo it is not an Object\n");

As you will see from the above code I ignore the use of the unset() method and rely solely on PHP's reference counter to ensure that my objects are cleaned up by the garbage collector (which is a fair assumption to make).

As you will see, instead I just set $this to 0 to achieve the same result. If you run the above code, you will get the class variable output, followed by "No it is not an Object". This has effectively deleted the object.

I also use this in my constructors sometimes to validate arguments passed into the (i.e.) "new test()" function call. If the constructor fails then "$this=0" is called and no object is actually returned. This effectively allows me to return a true/false value from a constructor (if true, an object is called, if false, no objectis returned). A quick call to is_object will then tell me if my object was constructed correctly.

Anyhow - let me have your comments on this. As far as I can tell it is the best way (at present) to achieve the required results with the least code!

the_Igel

Looks really cool. I like it!