PHP 5.6.0RC3 is available

Constructeurs et destructeurs

Constructeur

void __construct ([ mixed $args = "" [, $... ]] )

PHP permet aux développeurs de déclarer des constructeurs pour les classes. Les classes qui possèdent une méthode constructeur appellent cette méthode à chaque création d'une nouvelle instance de l'objet, ce qui est intéressant pour toutes les initialisations dont l'objet a besoin avant d'être utilisé.

Note: Les constructeurs parents ne sont pas appelés implicitement si la classe enfant définit un constructeur. Si vous voulez utiliser un constructeur parent, il sera nécessaire de faire appel à parent::__construct() depuis le constructeur enfant. Si l'enfant ne définit pas un constructeur alors il peut être hérité de la classe parent, exactement de la même façon qu'une méthode le serait (si elle n'a pas été déclarée comme privée).

Exemple #1 Exemple d'utilisation des nouveaux constructeurs unifiés

<?php
class BaseClass {
    function 
__construct() {
        print 
"In BaseClass constructor\n";
    }
}

class 
SubClass extends BaseClass {
    function 
__construct() {
        
parent::__construct();
        print 
"In SubClass constructor\n";
    }
}

class 
OtherSubClass extends BaseClass {
    
// Constructeur hérité de la classe BaseClass
}

// Dans le constructeur de la classe BaseClass
$obj = new BaseClass();

// Dans le constructeur de la classe BaseClass
// In SubClass constructor
$obj = new SubClass();

// Dans le constructeur de la classe BaseClass
$obj = new OtherSubClass();
?>

Pour des raisons de compatibilité ascendante, si PHP ne peut pas trouver une fonction __construct() pour une classe donnée, et que la classe n'en hérite pas de la classe parent, il cherchera une fonction constructeur représentée, comme dans l'ancien style (PHP < 5), par le nom de la classe. Dans les faits, cela signifie que le seul cas où il pourrait y avoir un problème de compatibilité est celui où votre classe contiendrait une méthode nommée __construct() et que vous en ayez un autre usage.

A la différence des autres méthodes, PHP ne génèrera pas d'erreur de niveau E_STRICT lorsque __construct() est surchargé avec des paramètres différents du __construct() parent.

Depuis PHP 5.3.3, les méthodes ayant le même nom que la classe dans laquelle elle se trouve ne sont plus traitées comme des constructeurs, si la classe considérée se situe dans un espace de noms. Ceci n'affecte pas les classes sans espace de noms.

Exemple #2 Constructeurs dans des classes dans des espaces de noms

<?php
namespace Foo;
class 
Bar {
    public function 
Bar() {
        
// Traitée comme un constructeur dans PHP 5.3.0-5.3.2
        // Traitée comme une méthode normale depuis PHP 5.3.3
    
}
}
?>

Destructeur

void __destruct ( void )

PHP 5 introduit un concept de destructeur similaire à celui d'autres langages orientés objet, comme le C++. La méthode destructeur est appelée dès qu'il n'y a plus de référence sur un objet donné, ou dans n'importe quel ordre pendant la séquence d'arrêt.

Exemple #3 Exemple avec un Destructeur

<?php
class MyDestructableClass {
    function 
__construct() {
        print 
"In constructor\n";
        
$this->name "MyDestructableClass";
    }

    function 
__destruct() {
        print 
"Destruction de " $this->name "\n";
    }
}

$obj = new MyDestructableClass();
?>

Tout comme le constructeur, le destructeur parent ne sera pas appelé implicitement par le moteur. Pour exécuter le destructeur parent, vous devez appeler explicitement la fonction parent::__destruct dans le corps du destructeur. Tout comme les constructeurs, une classe enfant peut hériter du destructeur du parent s'il n'en implémente pas un lui même.

Le destructeur sera appelé même si l'exécution du script est stoppée en utilisant la fonction exit(). Appeler la fonction exit() dans un destructeur empêchera l'exécution des routines d'arrêt restantes.

Note:

Les destructeurs appelées durant l'arrêt du script sont dans une situation où les en-têtes HTTP ont déjà été envoyés. Le dossier de travail dans la phase d'arrêt du script peut être différent avec certaines APIs (e.g. Apache).

Note:

Tenter de lancer une exception depuis un destructeur (appelé à la fin du script) entraine une erreur fatale.

add a note add a note

User Contributed Notes 53 notes

up
63
rayro at gmx dot de
3 years ago
the easiest way to use and understand multiple constructors:

<?php
class A
{
    function
__construct()
    {
       
$a = func_get_args();
       
$i = func_num_args();
        if (
method_exists($this,$f='__construct'.$i)) {
           
call_user_func_array(array($this,$f),$a);
        }
    }
   
    function
__construct1($a1)
    {
        echo(
'__construct with 1 param called: '.$a1.PHP_EOL);
    }
   
    function
__construct2($a1,$a2)
    {
        echo(
'__construct with 2 params called: '.$a1.','.$a2.PHP_EOL);
    }
   
    function
__construct3($a1,$a2,$a3)
    {
        echo(
'__construct with 3 params called: '.$a1.','.$a2.','.$a3.PHP_EOL);
    }
}
$o = new A('sheep');
$o = new A('sheep','cat');
$o = new A('sheep','cat','dog');

// results:
// __construct with 1 param called: sheep
// __construct with 2 params called: sheep,cat
// __construct with 3 params called: sheep,cat,dog
?>
up
16
nerdystudmuffin at gmail dot com
6 years ago
Correction to the previous poster about non public constructors. If I wanted to implement Singleton design pattern where I would only want one instance of the class I would want to prevent instantiation of the class from outside of the class by making the constructor private. An example follows:

class Foo {

  private static $instance;

  private __construct() {
    // Do stuff
  }

  public static getInstance() {

    if (!isset(self::$instance)) {
      $c = __CLASS__;
      $instance = new $c;
    }

    return self::$instance;
  }

  public function sayHello() {
    echo "Hello World!!";
  }

}

$bar = Foo::getInstance();

// Prints 'Hello World' on the screen.
$bar -> sayHello();
up
8
david dot scourfield at llynfi dot co dot uk
2 years ago
Be aware of potential memory leaks caused by circular references within objects.  The PHP manual states "[t]he destructor method will be called as soon as all references to a particular object are removed" and this is precisely true: if two objects reference each other (or even if one object has a field that points to itself as in $this->foo = $this) then this reference will prevent the destructor being called even when there are no other references to the object at all.  The programmer can no longer access the objects, but they still stay in memory.

Consider the following example:

<?php

header
("Content-type: text/plain");

class
Foo {
   
   
/**
     * An indentifier
     * @var string
     */
   
private $name;
   
/**
     * A reference to another Foo object
     * @var Foo
     */
   
private $link;

    public function
__construct($name) {
       
$this->name = $name;
    }

    public function
setLink(Foo $link){
       
$this->link = $link;
    }

    public function
__destruct() {
        echo
'Destroying: ', $this->name, PHP_EOL;
    }
}

// create two Foo objects:
$foo = new Foo('Foo 1');
$bar = new Foo('Foo 2');

// make them point to each other
$foo->setLink($bar);
$bar->setLink($foo);

// destroy the global references to them
$foo = null;
$bar = null;

// we now have no way to access Foo 1 or Foo 2, so they OUGHT to be __destruct()ed
// but they are not, so we get a memory leak as they are still in memory.
//
// Uncomment the next line to see the difference when explicitly calling the GC:
// gc_collect_cycles();
//
// see also: http://www.php.net/manual/en/features.gc.php
//

// create two more Foo objects, but DO NOT set their internal Foo references
// so nothing except the vars $foo and $bar point to them:
$foo = new Foo('Foo 3');
$bar = new Foo('Foo 4');

// destroy the global references to them
$foo = null;
$bar = null;

// we now have no way to access Foo 3 or Foo 4 and as there are no more references
// to them anywhere, their __destruct() methods are automatically called here,
// BEFORE the next line is executed:

echo 'End of script', PHP_EOL;

?>

This will output:

Destroying: Foo 3
Destroying: Foo 4
End of script
Destroying: Foo 1
Destroying: Foo 2

But if we uncomment the gc_collect_cycles(); function call in the middle of the script, we get:

Destroying: Foo 2
Destroying: Foo 1
Destroying: Foo 3
Destroying: Foo 4
End of script

As may be desired.

NOTE: calling gc_collect_cycles() does have a speed overhead, so only use it if you feel you need to.
up
5
Per Persson
2 years ago
As of PHP 5.3.10 destructors are not run on shutdown caused by fatal errors.

For example:
<?php
class Logger
{
    protected
$rows = array();

    public function
__destruct()
    {
       
$this->save();
    }

    public function
log($row)
    {
       
$this->rows[] = $row;
    }

    public function
save()
    {
        echo
'<ul>';
        foreach (
$this->rows as $row)
        {
            echo
'<li>', $row, '</li>';
        }
        echo
'</ul>';
    }
}

$logger = new Logger;
$logger->log('Before');

$nonset->foo();

$logger->log('After');
?>

Without the $nonset->foo(); line, Before and After will both be printed, but with the line neither will be printed.

One can however register the destructor or another method as a shutdown function:
<?php
class Logger
{
    protected
$rows = array();

    public function
__construct()
    {
       
register_shutdown_function(array($this, '__destruct'));
    }
   
    public function
__destruct()
    {
       
$this->save();
    }
   
    public function
log($row)
    {
       
$this->rows[] = $row;
    }
   
    public function
save()
    {
        echo
'<ul>';
        foreach (
$this->rows as $row)
        {
            echo
'<li>', $row, '</li>';
        }
        echo
'</ul>';
    }
}

$logger = new Logger;
$logger->log('Before');

$nonset->foo();

$logger->log('After');
?>
Now Before will be printed, but not After, so you can see that a shutdown occurred after Before.
up
2
maramirezc WHERE star-dev DOTTED com
4 years ago
Another way to emulate multiple constructors:

<?php
class MyClass {

  
// use a unique id for each derived constructor,
   // and use a null reference to an array,
   // for optional parameters
  
function __construct($id="", $args=null) {
      
// parent constructor called first ALWAYS
      
parent::__construct();

       echo
"main constructor\n";

     
// avoid null or other types
     
$id = (string) $id;

     
// allow default constructor
     
if ($id == "") { 
        
$id = "default";
      }

     
// just in case, use lowercase id
     
$id = "__cons_" strtolower($id);

     
$rc = new ReflectionClass("MyClass");

      if (!
$rc->hasMethod($id) {
         echo
"constructor $id not defined\n";
      }
      else {
       
// using "method references"
       
$this->$id($args);
      }

      
$rc = null;
   }
// function __construct

   // ALWAYS HAVE A default constructor,
   // that ignores arguments
  
function __cons_default($args=null) {
       echo
"Default constructor\n";
   }

  
// may have other constructors that expect different
   // argument types or argument count
  
function __cons_min($args=null) {
     if (!
is_array($args) || count($args) != 2) {
       echo
"Error: Not enough parameters (Constructor min(int $a, int $b)) !!!\n";
     }
     else {
        
$a = (int) $args[0];
        
$b = (int) $args[1];
        
$c = min($a,$b);
         echo
"Constructor min(): Result = $c\n";
     }
   }

  
// may use string index (associative array),
   // instead of integer index (standard array)
  
function __cons_fullname($args=null) {
     if (!
is_array($args) || count($args) < 2) {
       echo
"Error: Not enough parameters (Constructor fullname(string $firstname, string $lastname)) !!!\n";
     }
     else {
        
$a = (string) $args["firstname"];
        
$b = (string) $args["lastname"];
        
$c = $a . " " . $b;
         echo
"Constructor fullname(): Result = $c\n";
     }
   }

}
// class

// --> these two lines are the equivalent
$obj1 = new TestClass();
$obj2 = new TestClass("default");

// --> these two are specialized

// should be read as "$obj3 = new TestClass, min(99.7, 99.83);"
$obj3 = new TestClass("min", array(99.7, 99.83));

// should be read as "$obj4 = new TestClass, fullname("John", "Doe");"
$obj4 = new TestClass("fullname", array("firstname" => "John", "lastname" => "Doe"));

// --> these  two lack parameters
$obj5 = new TestClass("min", array());
$obj6 = new TestClass("fullname");

?>
up
2
spleen
5 years ago
It's always the easy things that get you -

Being new to OOP, it took me quite a while to figure out that there are TWO underscores in front of the word __construct.

It is __construct
Not _construct

Extremely obvious once you figure it out, but it can be sooo frustrating until you do.

I spent quite a bit of needless time debugging working code.

I even thought about it a few times, thinking it looked a little long in the examples, but at the time that just seemed silly(always thinking "oh somebody would have made that clear if it weren't just a regular underscore...")

All the manuals I looked at, all the tuturials I read, all the examples I browsed through  - not once did anybody mention this! 

(please don't tell me it's explained somewhere on this page and I just missed it,  you'll only add to my pain.)

I hope this helps somebody else!
up
3
apfelsaft
9 years ago
at the end of a script all remaining objects aren't in fact destructed. it is only their __destruct() method, which will be called. the objects still exist after that.

so, if your database connection object has no __destruct() or at least it doesn't disconnects the database, it will still work.

in general, there is no need to disconnect the database (especially for persistent connections).
up
4
phenixdoc at gmail dot com
3 years ago
multiple constructors with type signetures (almost overloading):

<?php
public function __construct() {
       
$args = func_get_args();
       
$argsStr = '';
        foreach (
$args as $arg) {
           
$argsStr .= '_' . gettype($arg);
        }
        if (
method_exists($this, $constructor = '__construct' . $argsStr))
           
call_user_func_array(array($this, $constructor), $args);
        else
            throw new
Exception('NO CONSTRUCTOR: ' . get_class() . $constructor, NULL, NULL);
    }

public function
__construct_integer($a) {}
public function
__construct_string($a) {}
public function
__construct_integer_string($a, $b) {}
public function
__construct_string_integer($a, $b) {}
?>
up
3
soapthgr8 at gmail dot com
7 years ago
This is just to clarify that the Singleton pattern is a bit more complex than just making the constructor private. It also involves caching an instance of the object and always returning the cached value. So, in the previous example, the getNewInstance() function would undermine the intent of the Singleton pattern. Instead you would just need a getInstance() function, like so.

<?php
class A {
 
// cached instance
 
private static oInst = null;

 
/**
    * Prevent an object from being constructed.
    */
 
private function __construct( ) {}
 
/**
   * Function to return the instance of this class.
   */
 
public static function getInstance( ) {
    if (
is_null(self::$oInst)) {
     
self::$oInst = new A( );
    }
    return
self::$oInst;
  }
}
?>
up
2
prieler at abm dot at
7 years ago
i have written a quick example about the order of destructors and shutdown functions in php 5.2.1:

<?php
class destruction {
    var
$name;

    function
destruction($name) {
       
$this->name = $name;
       
register_shutdown_function(array(&$this, "shutdown"));
    }

    function
shutdown() {
        echo
'shutdown: '.$this->name."\n";
    }

    function
__destruct() {
        echo
'destruct: '.$this->name."\n";
    }
}

$a = new destruction('a: global 1');

function
test() {
   
$b = new destruction('b: func 1');
   
$c = new destruction('c: func 2');
}
test();

$d = new destruction('d: global 2');

?>

this will output:
shutdown: a: global 1
shutdown: b: func 1
shutdown: c: func 2
shutdown: d: global 2
destruct: b: func 1
destruct: c: func 2
destruct: d: global 2
destruct: a: global 1

conclusions:
destructors are always called on script end.
destructors are called in order of their "context": first functions, then global objects
objects in function context are deleted in order as they are set (older objects first).
objects in global context are deleted in reverse order (older objects last)

shutdown functions are called before the destructors.
shutdown functions are called in there "register" order. ;)

regards, J
up
2
fredrik at rambris dot com
7 years ago
The fact that class names are case-insensitive in PHP5 also applies to constructors. Make sure you don't have any functions named like the class *at all*.

This has bitten me a few times.

<?php
class Example extends Base
{
  function
example()
  {
    echo
"This gets called";
  }
}

class
Base
{
  function
__construct()
  {
    echo
"Not this";
  }
}

?>
up
2
Reza Mahjourian
8 years ago
Peter has suggested using static methods to compensate for unavailability of multiple constructors in PHP.  This works fine for most purposes, but if you have a class hierarchy and want to delegate parts of initialization to the parent class, you can no longer use this scheme.  It is because unlike constructors, in a static method you need to do the instantiation yourself.  So if you call the parent static method, you will get an object of parent type which you can't continue to initialize with derived class fields.

Imagine you have an Employee class and a derived HourlyEmployee class and you want to be able to construct these objects out of some XML input too.

<?php
class Employee {
   public function
__construct($inName) {
      
$this->name = $inName;
   }

   public static function
constructFromDom($inDom)
   {
      
$name = $inDom->name;
       return new
Employee($name);
   }

   private
$name;
}

class
HourlyEmployee extends Employee {
   public function
__construct($inName, $inHourlyRate) {
      
parent::__construct($inName);
      
$this->hourlyRate = $inHourlyRate;
   }

   public static function
constructFromDom($inDom)
   {
      
// can't call parent::constructFromDom($inDom)
       // need to do all the work here again
      
$name = $inDom->name// increased coupling
      
$hourlyRate = $inDom->hourlyrate;
       return new
EmployeeHourly($name, $hourlyRate);
   }

   private
$hourlyRate;
}
?>

The only solution is to merge the two constructors in one by adding an optional $inDom parameter to every constructor.
up
2
Yousef Ismaeil cliprz[At]gmail[Dot]com
11 months ago
<?php

/**
* a funny example Mobile class
*
* @author Yousef Ismaeil Cliprz[At]gmail[Dot]com
*/

class Mobile {

   
/**
     * Some device properties
     *
     * @var string
     * @access public
     */
   
public $deviceName,$deviceVersion,$deviceColor;
   
   
/**
     * Set some values for Mobile::properties
     *
     * @param string device name
     * @param string device version
     * @param string device color
     */
   
public function __construct ($name,$version,$color) {
       
$this->deviceName = $name;
       
$this->deviceVersion = $version;
       
$this->deviceColor = $color;
        echo
"The ".__CLASS__." class is stratup.<br /><br />";
    }
   
   
/**
     * Some Output
     *
     * @access public
     */
   
public function printOut () {
        echo
'I have a '.$this->deviceName
           
.' version '.$this->deviceVersion
           
.' my device color is : '.$this->deviceColor;
    }
   
   
/**
     * Umm only for example we will remove Mobile::$deviceName Hum not unset only to check how __destruct working
     *
     * @access public
     */
   
public function __destruct () {
       
$this->deviceName = 'Removed';
        echo
'<br /><br />Dumpping Mobile::deviceName to make sure its removed, Olay :';
       
var_dump($this->deviceName);
        echo
"<br />The ".__CLASS__." class is shutdown.";
    }

}

// Oh ya instance
$mob = new Mobile('iPhone','5','Black');

// print output
$mob->printOut();

?>

The Mobile class is stratup.

I have a iPhone version 5 my device color is : Black

Dumpping Mobile::deviceName to make sure its removed, Olay :
string 'Removed' (length=7)

The Mobile class is shutdown.
up
2
ashnazg at php dot net
6 years ago
While experimenting with destructs and unsets in relation to memory usage, I found what seems to be one useful way to predict when __destruct() gets called... call it manually yourself.

I had previously assumed that explicitly calling unset($foo) would cause $foo->__destruct() to run implicitly, but that was not the behavior I saw (php 5.2.5).  The destructors weren't running until the script ended, even though I was calling unset($foo) in the middle of my script.  So, having $foo->__destruct() unset all of $foo's component objects was not helping my memory usage since my explicit unset($foo) was _not_ triggering $foo->__destruct()'s cleanup steps.

Interestingly, what _did_ appear to happen is that calling unset($bar) from inside a destructor like $foo->__destruct() _DID_ cause $bar->__destruct() to be implicitly executed.  Perhaps this is because $bar has a "parent" reference of $foo whereas $foo does not, and the object destruction behaves differently... I don't know.

Lastly, even after explicitly calling $foo->__destruct() (even when it had "unset($this);" inside it), the reference to the $foo object remained visible.  I had to still explicitly call unset($foo) to get rid of it.

So, my advice based on the behavior I saw in my experiments:
- always unset($bar) your class's component objects from inside that class's __destruct() method;  no explicit component destructor calls seem to be required other than those unsets, though.
- always explicitly call $foo->__destruct() in your code that _uses_ your class
- always explicitly follow $foo->__destruct() with unset($foo).

This seems to be the best cleanup approach to take.  Just for my own sanity, I also will always keep an unset($this) at the end of each __destruct() method.
up
2
marvinpetker at gmail dot com
8 days ago
Despite its casesensetivity PHP will call methods in lower case with the same name as the class as a constructor.

<?php
class Test{
  public function
test(){
   
//This will be called as a counstructor.
 
}
}
?>
up
2
Anonymous
7 months ago
By inheriting from this class, you can do constructor overloading in terms of type hinting.
<?php
  
abstract class OverloadedConstructors {
      public final function
__construct() {
        
$self = new ReflectionClass($this);
        
$constructors = array_filter($self->getMethods(ReflectionMethod::IS_PUBLIC), function(ReflectionMethod $m) {
            return
substr($m->name, 0, 11) === '__construct';
         });
         if(
sizeof($constructors) === 0)
           
trigger_error('The class ' . get_called_class() . ' does not provide a valid constructor.', E_USER_ERROR);
        
$number = func_num_args();
        
$arguments = func_get_args();
         foreach(
$constructors as $constructor) {
            if((
$number >= $constructor->getNumberOfRequiredParameters()) &&
               (
$number <= $constructor->getNumberOfParameters())) {
              
$parameters = $constructor->getParameters();
              
reset($parameters);
               foreach(
$arguments as $arg) {
                 
$parameter = current($parameters);
                  if(
$parameter->isArray()) {
                     if(!
is_array($arg))
                        continue
2;
                  }elseif((
$expectedClass = $parameter->getClass()) !== null) {
                     if(!(
is_object($arg) && $expectedClass->isInstance($arg)))
                        continue
2;
                  }
                 
next($parameters);
               }
              
$constructor->invokeArgs($this, $arguments);
               return;
            }
         }
        
trigger_error('The required constructor for the class ' . get_called_class() . ' did not exist.', E_USER_ERROR);
      }
   }
?>
Simply define a class like this:
<?php
  
class Test extends OverloadedConstructors {
      public function
__construct1(array $arg) {
         die(
'First construct');
      }

      public function
__construct2(stdClass $test) {
         die(
'Second construct');
      }

      public function
__construct3($optional = null) {
         die(
'Third construct');
      }
   }
?>
You can define as much constructors as you wish and limit them by php's type hinting. Note that the constructor signatures should be non-ambiguous.
up
1
kayvin86 at live dot com
2 months ago
putting in more layman's term

class dad{
   
    function __construct() {
        echo get_class($this) . ' is fair and tall <br>';
    }
}

//inherit and overidding parent constructor
class son extends dad{
   
    function __construct(){
        parent::__construct();
        echo get_class($this) . ' is handsome <br>';
    }
}

//overidding parent constructor
class daughter extends dad{
    function __construct(){
        echo get_class($this) . ' is tan like her mother <br>';
        echo get_class($this) . ' is pretty and has nothing to do with dad <br>';
    }
}

echo 'im dad: <br>';
$dad = new dad();

echo '<br>';

echo 'born a son: <br>';
$son = new son();

echo '<br>';

echo 'born a daughter: <br>';
$daughter = new daughter();

/*output
im dad:
dad is fair and tall

born a son:
son is fair and tall (notice that when parent:: is call inside son, son will be the class inside dad's contructor)
son is handsome

born a daughter:
daughter is tan like her mother
daughter is pretty and has nothing to do with dad
*/
up
2
Jonathon Hibbard
4 years ago
Please be aware of when using __destruct() in which you are unsetting variables...

Consider the following code:
<?php
class my_class {
  public
$error_reporting = false;

  function
__construct($error_reporting = false) {
   
$this->error_reporting = $error_reporting;
  }

  function
__destruct() {
    if(
$this->error_reporting === true) $this->show_report();
    unset(
$this->error_reporting);
  }
?>

The above will result in an error:
Notice: Undefined property: my_class::$error_reporting in my_class.php on line 10

It appears as though the variable will be unset BEFORE it actually can execute the if statement.  Removing the unset will fix this.  It's not needed anyways as PHP will release everything anyways, but just in case you run across this, you know why ;)
up
2
bac2day1 at gmail dot com
5 years ago
You can also capitalize on singleton for the connection as well.
Just add the following to your class:

<?php
class db {
 
//...
 
private static $instance;
 
//...
 
public static function singleton() {
    if(!isset(
self::$instance)) {
     
$c = __CLASS__;
     
self::$instance = new $c();
    }
    return
self::$instance;
  }
 
//...
}
?>
up
2
Anonymous
5 years ago
USE PARENT::CONSTRUCT() to exploit POLYMORPHISM POWERS

Since we are still in the __construct and __destruct section, alot of emphasis has been on __destruct - which I know nothing about. But I would like to show the power of parent::__construct for use with PHP's OOP polymorphic behavior (you'll see what this is very quickly).

In my example, I have created a fairly robust base class that does everything that all subclasses need to do. Here's the base class def.

<?php

/*
* Animal.php
*
* This class holds all data, and defines all functions that all
* subclass extensions need to use.
*
*/
abstract class Animal
{
  public
$type;
  public
$name;
  public
$sound;

 
/*
   * called by Dog, Cat, Bird, etc.
   */
 
public function __construct($aType, $aName, $aSound)
  {
   
$this->type = $aType;
   
$this->name = $aName;
   
$this->sound = $aSound;
  }

 
/*
   * define the sorting rules - we will sort all Animals by name.
   */
 
public static function compare($a, $b)
  {
    if(
$a->name < $b->name) return -1;
    else if(
$a->name == $b->name) return 0;
    else return
1;
  }

 
/*
   * a String representation for all Animals.
   */
 
public function __toString()
  {
    return
"$this->name the $this->type goes $this->sound";
  }
}

?>

Trying to instantiate an object of type Animal will not work...

$myPet = new Animal("Parrot", "Captain Jack", "Kaaawww!"); // throws Fatal Error: cannot instantiate abstract class Animal.

Declaring Animal as abstract is like killing two birds with one stone. 1. We stop it from being instantiated - which means we do not need a private __construct() or a static getInstance() method, and 2. We can use it for polymorphic behavior. In our case here, that means "__construct", "__toString" and "compare" will be called for all subclasses of Animal that have not defined their own implementations.

The following subclasses use parent::__construct(), which sends all new data to Animal. Our Animal class stores this data and defines functions for polymorphism to work... and the best part is, it keeps our subclass defs super short and even sweeter.

<?php

class Dog extends Animal{
  public function
__construct($name){
   
parent::__construct("Dog", $name, "woof!");
  }
}

class
Cat extends Animal{
  public function
__construct($name){
   
parent::__construct("Cat", $name, "meeoow!");
  }
}

class
Bird extends Animal{
  public function
__construct($name){
   
parent::__construct("Bird", $name, "chirp chirp!!");
  }
}

# create a PHP Array and initialize it with Animal objects
$animals = array(
  new
Dog("Fido"),
  new
Bird("Celeste"),
  new
Cat("Pussy"),
  new
Dog("Brad"),
  new
Bird("Kiki"),
  new
Cat("Abraham"),
  new
Dog("Jawbone")
);

# sort $animals with PHP's usort - calls Animal::compare() many many times.
usort($animals, array("Animal", "compare"));

# print out the sorted results - calls Animal->__toString().
foreach($animals as $animal) echo "$animal<br>\n";

?>

The results are "sorted by name" and "printed" by the Animal class:

Abraham the Cat goes meeoow!
Brad the Dog goes woof!
Celeste the Bird goes chirp chirp!!
Fido the Dog goes woof!
Jawbone the Dog goes woof!
Kiki the Bird goes chirp chirp!!
Pussy the Cat goes meeoow!

Using parent::__construct() in a subclass and a super smart base class, gives your child objects a headstart in life, by alleviating them from having to define or handle several error and exception routines that they have no control over.

Notice how subclass definitions are really short - no variables or functions at all, and there is no private __construct() method anywhere? Notice how objects of type Dog, Cat, and Bird are all sorted by our base class Animal? All the class definitions above address several issues (keeping objects from being instantiated) and enforces the desired, consistent, and reliable behavior everytime... with the least amount of code. In addition, new extenstions can easily be created. Each subclass is now super easy to redefine or even extend... now that you can see a way to do it.
up
0
philipwaynerollins at gmail dot com
2 years ago
With the destructor if you're going to write to a file make sure you have the full file path and not just the filename, it seems PHP switches the working directory to the apache root directory when exiting the script.
up
0
alon dot peer at gmail dot com
4 years ago
Another way to overcome PHP's lack of multi constructors support is to check for the constructor's parameters' type and variate the operation accordingly. This works well when the number of parameters stays the same in all your constructors' needs.

Example:

<?php

class Articles {

    private
$_articles_array;

    public function
__construct($input) {
        if (
is_array($input)) {
           
// Initialize articles array with input.
       
}
        else if (
$input instanceof SimpleXMLElement) {
           
// Initialize articles array by parsing the XML.
       
}
        else {
            throw new
Exception('Wrong input type');
        }
    }

}

?>
up
0
thomasrutter
4 years ago
The manual page says that throwing an exception from a destructor causes a fatal error;  I've found that this only happens when the exception is _uncaught_ within the context of that destructor.  If you catch it within that same destructor it seems to be fine.

This is equally true of other contexts, such as:
- shutdown functions set with register_shutdown_function
- destructors
- custom session close functions
- custom error handlers
- perhaps other similar contexts

An exception normally 'bubbles up' to higher and higher contexts until it is caught, but because a destructor or shutdown function is called not within execution flow but in response to a special PHP event, the exception is unable to be traced back any further than the destructor or shutdown function in which it is called.
up
1
ashnazg at php dot net
6 years ago
Since my last note, I've been instructed to _NEVER_ call "unset($this)", never ever ever.  Since my previous testing of behavior did not explicitly show me that it was indeed necessary, I'm inclined to trust those telling me not to do it.
up
0
ruggie0 at yahoo dot com
4 years ago
For those who still ***have*** to deal with php4 (like myself, which sucks), contact at tcknetwork dot com noted below that you can have both __constructor and function [classname] in the script, as __constructor has priority.

However, to further improve compatability, do a version check in function [classname], as I do in my classes as follows:
<?php
  
class Foo{
      function
__construct($arg){
         echo
$arg;
      }

      function
Foo($arg){
         if(
version_compare(PHP_VERSION,"5.0.0","<")){
           
$this->__construct($arg);
           
register_shutdown_function(array($this,"__destruct"));         
         }
      }

      function
__destruct(){
         echo
"Ack! I'm being destroyed!";
      }
   }
?>

This makes it much easier to use your script with fewer compatibility issues.
up
0
enrico dot modanese at alpj dot com
4 years ago
It's usefull to note that parent::__construct() is executed like a standalone function called into the new one, and not like a first part of the code. So "return" or "die()" don't have effect on following code. If you want to avoid the execution of the child constructor you have to pass some condition from the parent. Example:

<?php
class X {
  function
X(){
    if(
$_POST['break']=='yes'){return;}
    }
  }

class
Y extends X{
  function
Y(){
   
parent::__construct();
    print(
"Y_constructor_finished");
    }
  }

$_POST['break']=='yes';
$new_Y=new Y();  // will print "Y_constructor_finished"

Solution:

class
X {
  function
X(){
    if(
$_POST['break']=='yes'){$this->break='yes';return;}
    }
  }

class
Y extends X{
  function
Y(){
   
parent::__construct();
    if(
$this->break=='yes'){return;}
    print(
"Y_constructor_finished");
    }
  }

$_POST['break']='yes';
$new_Y=new Y();  // will print nothing
?>
up
0
hyponiq at gmail dot com
5 years ago
I just thought I'd share some valuable information that might help novice programmers/scripters in __constructor() functions.

I've been using PHP for quite a long time, as well as programming and scripting in general.  Even with my quite seasoned skillset, I still make obvious, painstaking mistakes.  That said, I'd like to point out one major (albeit obvious) common mistake that programmers and scripters (such as myself) make.

When defining the constructor for an object and using it to populate variables for use throughout the lifetime of the application, do note that if you set a static variable AFTER a dynamic one, the static variable's (intended) contents are not readible inside the assigning functions of a dynamic variable.  (That sounded rather cryptic, so an example is in order...)

<?php
class ExampleClass
{
   
// assigned a static value using an expression in the constructor
   
public $myStaticVar;
   
   
// assigned a value through a function of the class
   
public $myDynamicVar;
   
    public function
__construct($myStaticVarValue)
    {
       
// sets to nothing; $this->myStaticVar hasn't been assigned to yet
       
$this->myDynamicVar = $this->setSomeValue();
       
       
// sets to 'Static Variable Value in this example
       
$this->myStaticVar = $myStaticVarValue;
    }
   
    public function
setSomeValue()
    {
       
// returns null; $this->myStaticVar hasn't been assigned to, yet
       
return $this->myStaticVar;
    }
}

// automatically sets $object->myStaticVar to 'Static Variable Value'
//(but only after setting $object->myDynamicVar to the unassigned $object->myStaticVar)
$object = new ExampleClass('Static Variable Value');

// outputs nothing
print $object->myDynamicVar;
?>

The above example won't print anything because you're setting the $myDynamicVar to equal the $myStaticVar, but the $myStaticVar hasn't been (technically) assigned to, yet.

So, if you wish to reference that variable inside the assignment function of a dynamic variable, you have to declare it first and foremost.  Otherwise, its value will not be accessible yet.

The correct way...
<?php
class ExampleClass
{
   
// assigned a static value using an expression in the constructor
   
public $myStaticVar;
   
   
// assigned a value through a function of the class
   
public $myDynamicVar;
   
    public function
__construct($myStaticVarValue)
    {
       
// sets to $myStaticVariable (or 'Some Static Variable Value' in this example)
       
$this->myStaticVar = $myStaticVarValue;
       
       
// sets to newly assigned-to $this->myStaticVariable
       
$this->myDynamicVar = $this->setSomeValue();
    }
   
    public function
setSomeValue()
    {
       
// returns 'Static Variable Value'
       
return $this->myStaticVar;
    }
}

// sets $object->myStaticVar to 'Static Variable Value' automatically before $object->myDynamicVar
$object = new ExampleClass('Static Variable Value');

// outputs 'Static Variable Value'
print $object->myDynamicVar;
?>
up
0
office at kitsoftware dot ro
5 years ago
Should be noted that according to the NEWS (in PHP 5.3) file, in PHP 5.3, handling an exception in the __destructor should not output a FATAL error ...
up
0
Jeffrey
5 years ago
Constructor Simplicity

If your class DOES CONTAIN instance members (variables) that need to be set, then your class needs to be initialized... and you should use __construct() to do that.

<?php
class MyClassA {
  public
$data1, $data2;

  public function
__construct($mcd1, $mcd2) {
   
$this->data1 = $mcd1// INITIALIZE $data1
   
$this->data2 = $mcd2// INITIALIZE $data2
 
}
}

$obj1 = new MyClassA("Hello", "World!");  // INSTANTIATE MyClassA
$d1 = $obj1->data1;
$d2 = $obj1->data2;
?>

If your class DOES NOT CONTAIN instance members or you DO NOT want to instantiate it, then there is no reason to initialize it or use __construct().

<?php
class MyClassB {
  const
DATA1 = "Hello";
  public static
$data2 = "World!";
}

$obj1 = new MyClassB();  // INSTANTIATE MyClassB - NO error.
$d1 = $obj1::DATA1;      // ERROR
$d2 = $obj1::data2;      // ERROR
$d1 = MyClassB::DATA1;   // ok
$d2 = MyClassB::$data2// ok
?>

The fact that $obj1 is useless and cannot be used as a reference, is further evidence that MyClassB objects should not be instantiated. NOTICE that MyClassB does not use private members or functions to make it behave that way. Rather, it is the collective nature of all the class members + what ISN'T there.
up
0
KK
6 years ago
I ran into an interesting (and subtle) code error while porting some code to PHP 5.2.5 from PHP 4.4.8 that I think illustrates a noteworthy semantic.

I have a hierarchy of classes with both styles of constructors but where one in the middle was missing the __construct() function (it just had the old-style one that called the (nonexistent) __construct()).  It worked fine in PHP4 but caused an endless loop (and stack overflow) in PHP5.  I believe what happened is that in PHP4 the old-style constructor was not called, but in PHP5 it was (due to the "emulation" of PHP4), and since _construct() wasn't defined for that class, the call to $this->__construct() caused a looping call to the original (lowest child) constructor.
up
0
bolshun at mail dot ru
6 years ago
Ensuring that instance of some class will be available in destructor of some other class is easy: just keep a reference to that instance in this other class.
up
0
david at synatree dot com
6 years ago
When a script is in the process of die()ing, you can't count on the order in which __destruct() will be called.

For a script I have been working on, I wanted to do transparent low-level encryption of any outgoing data.  To accomplish this, I used a global singleton class configured like this:

class EncryptedComms
{
    private $C;
    private $objs = array();
    private static $_me;
   
    public static function destroyAfter(&$obj)
    {
        self::getInstance()->objs[] =& $obj;
        /*
            Hopefully by forcing a reference to another object to exist
            inside this class, the referenced object will need to be destroyed
            before garbage collection can occur on this object.  This will force
            this object's destruct method to be fired AFTER the destructors of
            all the objects referenced here.
        */
    }
    public function __construct($key)
    {
            $this->C = new SimpleCrypt($key);
            ob_start(array($this,'getBuffer'));
    }
    public static function &getInstance($key=NULL)
    {
        if(!self::$_me && $key)
            self::$_me = new EncryptedComms($key);
        else
            return self::$_me;
    }
   
    public function __destruct()
    {
        ob_end_flush();
    }
   
    public function getBuffer($str)
    {
        return $this->C->encrypt($str);
    }

}

In this example, I tried to register other objects to always be destroyed just before this object.  Like this:

class A
{

public function __construct()
{
     EncryptedComms::destroyAfter($this);
}
}

One would think that the references to the objects contained in the singleton would be destroyed first, but this is not the case.  In fact, this won't work even if you reverse the paradigm and store a reference to EncryptedComms in every object you'd like to be destroyed before it.

In short, when a script die()s, there doesn't seem to be any way to predict the order in which the destructors will fire.
up
0
Typer85 at gmail dot com
6 years ago
In regards to a Class Constructor visibility ...

I too was having the same problem with Class Constructor visibility, in which I had one Class that was extended by several other Classes. The problem that I encountered was in one of the Child Classes, I wanted a weaker visibility. Consider the following example:

<?php

class A {
   
   
// Public Constructor ...
    // No Problems Here.
   
   
public function __construct( ) {
       
    }
   
   
// Class Function.
   
   
public function functionA( ) {
       
    }
}

class
B extends A {
   
   
// Public Constructor ...
    // Same As Parent Class ...
    // Again No Problems Here.
   
   
public function __construct( ) {
       
    }
   
   
// Class Function.
   
   
public function functionB( ) {
       
    }
}

class
C extends A {
   
   
// Private Constructor ...
    // Weaker Then Parent Class ...
    // PHP Will Throw A Fatal Error.
   
   
private function __construct( ) {
       
    }
   
   
// Class Function.
   
   
public function functionC( ) {
       
    }
}

?>

Nothing new in the above example that we have not seen before. My solution to solve this problem?

Create an Abstract Class with all the functionality of Class A.  Make its Class Constructor have a visibility of Protected, then extend each of the three Classes above from that Abstract Class. In a way, the Abstract Class acts as a dummy Class to get rid of the visibility problem:

<?php

abstract class AAbstract {
   
   
// Protected Constructor ...
    // Abstract Class Can Not Be Created Anyway ...
    // No Problems Here.
   
   
protected function __construct( ) {
       
    }
   
   
// Class Function ...
    // Originally In Class A ...
    // Which Was Used As A Super Class.
   
   
public function functionA( ) {
       
    }
}

class
A extends AAbstract {
   
   
// Public Constructor ...
    // Stronger Than Parent Class ...
    // Again No Problems Here.
   
   
public function __construct( ) {
       
       
// By Moving All The Functionality Of
        // Class A To Class AAbstract Class A
        // Will Automatically Inherit All Of
        // Its Functionality. The Only Thing
        // Left To Do Is To Create A Constructor
        // Which Calls Class AABstract's Constructor
        // To Mimic Similar Behavior.
       
       
parent::__construct( );
    }
   
   
// No Need To Redeclare functionA( )
    // Since It Was Moved To Class
    // AAbstract.
}

class
B extends AAbstract  {
   
   
// Public Constructor ...
    // Stronger Than Parent Class ...
    // Again No Problems Here.
   
   
public function __construct( ) {
       
       
parent::__construct( );
    }
   
   
// Class Function ...
    // Specific To This Class.
   
   
public function functionB( ) {
       
    }
}

class
C extends AAbstract {
   
   
// Protected Constructor ...
    // Same As Parent Class ...
    // Again No Problems Here.
   
   
protected function __construct( ) {
       
    }
   
   
// Class Function ...
    // Specific To This Class.
   
   
public function functionC( ) {
       
    }
}

?>

As you can see the problem is more or less fixed. Class AAbstract acts a dummy class, containing all the original functionality of Class A. But because it has a protected Constructor, in order to make its functionality available, Class A is redeclared as Child Class with the only difference of it having a public Constructor that automatically calls the Parent Constructor.

Notice that Class B does not extend from Class A but also from Class AAbstract! If I wanted to change Class B's Constructor to protected, I can easily do it! Notice that an extra Method was added to Class B ... this is because Class B has extra functionality specific to itself. Same applies to Class C.

Why don't Class B and Class C extend from Class A? Because Class A has a public Constructor, which pretty much defies the point of this solution.

This solution is not perfect however and has some flaws.

Good Luck,
up
0
James Laver
6 years ago
I recently found, while implementing a database backed session class, that PHP has an apparently less than desirably structured destruction order. Basically, my session class which would have saved when destructed, was being destructed after one of the classes it depends on. Apparently we cannot, therefore depend on PHP to use reverse initialisation order.

My solution was to use register_shutdown_function, which is called before any objects are killed on script end.

Quick example (if you're going to use it, I recommend tidying up the code somewhat) :
<?php
class Session
 
function __construct()
  {
   
//Initialise the session here...
   
    //Register the shutdown function
   
register_shutdown_function(array($this,"save"));
  }

  function
save()
  {
   
//Save it here
 
}

  function
__destruct()
  {
   
//Persisting the session here will not work.
 
}
?>
up
0
magus do t xion a t g mail d ot c o m
6 years ago
Looking through the notes I noticed a few people expressing concern that PHP5 does not support multiple constructors...

Here is an example of a method that I use which seems to work fine:

class Example
{
     function __construct()
     {
           echo "do some basic stuff here";
     }

     function Example($arg)
     {
           echo $arg;
     }
}

You then can call with or without arguments without having notices and/or warnings thrown at you... Of course this is limited but if you don't need something complex this can help to get the job done in some situations.  I believe you could also add arguments to the __construct() function and as long as it is different than Example() 's args you would be fine. Although I have yet to test this.
up
0
theubaz at gmail dot com
7 years ago
What you could do is write the constructor without any declared arguments, then iterate through the arguments given and check their types/values to determine what other function to use as the constructor.
up
0
frederic dot barboteu at laposte dot net
7 years ago
The manual says:
"Like constructors, parent destructors will not be called implicitly by the engine."

This is true ONLY when a __destruct() function has been defined by the child class.
If no __destruct() function exists in the child class, the parent's one will be implicitly executed.

So be carefull if you have some ancestor executing a particular task in its __destruct() function, an you plan its childs to execute it or not, wether you include "parent::__destruct()" or not.
If you want the child not to execute its parent __destruct() function, you must ensure that it has its own __destruct() function, even if empty. Then the parent's one will not be executed.

This can be verified with the following code:
<?php
#
class AncestorClass {
    function
__destruct() {
        echo
'<br />AncestorClass: destructing '.get_class($this);
    }
}
#
class ParentDestructClass extends AncestorClass {
    function
__destruct() {
        echo
'ParentDestructClass: destructing itself';
       
parent::__destruct();
    }
}
#
class EmptyDestructClass extends AncestorClass {
    function
__destruct() {
        echo
'EmptyDestructClass: destructing itself';
    }
}
#
class NoDestructClass extends AncestorClass {
}
#---
echo '<hr>';
$p=new ParentDestructClass();
unset(
$p);
echo
'<hr>';
$e=new EmptyDestructClass();
unset(
$e);
echo
'<hr>';
$n=new NoDestructClass();
unset(
$n);
echo
'<hr>';
?>
which displays:
---
ParentDestructClass: destructing itself
AncestorClass: destructing ParentDestructClass
---
EmptyDestructClass: destructing itself
---

AncestorClass: destructing NoDestructClass
---
up
0
phaxius
7 years ago
Hello, I've been messing with php for about a week but am learning a lot.  It occurred to me that it might be necessary in some cases to write a class that takes a variable number of arguments.  After some experimentation, this example was formed:

class variableArgs{
public $a = array();
protected $numOfArgs;
public function __construct()
{
  $numOfArgs=func_num_args();
  if(func_num_args()==0)
  {
    $numOfArgs=1;
    $a[0]='No arguments passed';
    $this->Arg[0]=$a[0];
  }
  else
  for($i=0; $i<func_num_args(); $i++)
  {
    $a[$i]=func_get_arg($i);
    $this->Arg[$i]=$a[$i];
  }
}
public function showArgs()
{
  echo 'showArgs() called <br />';
  for ($i=0; $i<$numOfArgs; $i++)
  {
    echo '$i: ' . $i . '<br />';
    echo $this->Arg[$i];
    echo '<br />';
  }
}
public function __destruct(){}

}

$test1 = new variableArgs;
$test2 = new variableArgs("arg1");
$test3 = new variableArgs("arg1", "arg2");
$test4 = new variableArgs("arg1", "arg2", "arg3");

$test1->showArgs();
$test2->showArgs();
$test3->showArgs();
$test4->showArgs();

This outputs the following:

showArgs() called
$i: 0
No arguments passed
showArgs() called
$i: 0
arg1
showArgs() called
$i: 0
arg1
$i: 1
arg2
showArgs() called
$i: 0
arg1
$i: 1
arg2
$i: 2
arg3

I have no idea how efficient this is, but it works at any rate.  Hopefully this helps someone.
up
0
Anonymous
7 years ago
This is a simple thing to bear in mind but it's also easy to forget it.  When chaining object constructors and destructors, always remember to call the superclass __construct() method in the subclass __construct() so that all superclass members are properly initialized before you start initializing the ones belonging to your subclass. 

Also, you will usually want to do your own cleanup first in your subclass __destruct() method so you will probably want to call the superclass __destruct() as the last thing in your subclass so that you can use resources defined in the superclass during the cleanup phase.

For example, if your superclass includes a database connection and your subclass __destruct method commits things to the database then if you call the superclass destruct before doing so then the database connection will no longer be valid and you will be unable to commit your changes.
up
0
chanibal at deltasoft dot int dot pl dot SPAMPROTECT
7 years ago
Note that if a class contains another class, the contained class's destructor will be triggered after the destructor of the containing class.

<?php
class contained {

protected
$parent;

public function
__construct(&$p) {
 
# $this->parent=&$p;
 
}

public function
__destruct() {
 
/* unset $this->parent */
 
print 'contained ';
  }
}

class
containing {

protected
$contained;

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

public function
__destruct() {
 
// unset($this->contained);
 
print 'containing ';
  }
}


new
containing();
?>

Will output
containing contained

After uncommenting the // comment, the output will change to
contained containing

Adding a reference from the contained class to the containing one (the # comment) will not change that, but beware, because it can cause random errors in other destructors in the parts of the script which seem unrelated! (PHP Version 5.1.2)
up
0
Peter Molnar
8 years ago
There were many notes about the inability of defining multiple constructors for the class.

My solution is to define separate static methods for each type of constructor.
<?php
class Vector {
    private
$x;
    private
$y;

    public function
__construct() {
       
$this->x = 0;
       
$this->y = 0;
    }

    public static function
createXY($x, $y) {
       
$v = new Vector();
       
$v->x = $x;
       
$v->y = $y;
        return
$v;
    }
}
?>
up
0
jcaplan at bogus dot amazon dot com
8 years ago
__construct and __destruct must be declared public in any class that you intend to instantiate with new.   However, in an abstract (or never-instantiated base) class you can declare them private or protected, and subclasses can still refer to them via parent::__construct (!) (tested in PHP 5.1.2).
up
-2
ramesh dot rips at gmail dot com
5 years ago
Without __constructor constructor will call like this.
Why because, Here Class name and function name are equal.
<?php
class baseclass
{
  function
baseclass()
  {
    echo
"constructor is called"."<br>" ;
   }
}
class
deriviedclass extends baseclass
{
   function
deriviedclass()
   {
      
parent::baseclass();
     }
  }

$object_base=new baseclass();
$object_derive=new deriviedclass();
?>
Out put is
constructor is called
constructor is called
up
0
contact at tcknetwork dot com
8 years ago
be careful while trying to access files with __destruct() because the base directory (getcwd()) will be the root of your server and not the path of your script, so add before all your path called in __destruct() :
EITHER   dirname($_SERVER["SCRIPT_FILENAME"])."my/path/"
OR      dirname(__FILE__)."my/path/"
         (be careful with includes, it will give the path of the file processed and not the main file)
up
-2
ceo at l-i-e dot com
5 years ago
As far as I can tell, Connection: close isn't sent until after __destruct is called in shutdown sequence.
I was hoping to get the HTTP connection closed and done, and do some slow non-output processing after that, but no luck.
up
0
php dot net at lk2 dot de
8 years ago
It looks like `echo()`ed output from the __destructor() function is displayed onto screen _before_ other output that the class may have have already sent before.

This can be misleading if you have debug info printed in the destructor but not a problem if you know it.
up
-2
derk AT oneindig DOT com
8 years ago
If a constructor is not present in a child class, php5 will try to call a constructor from the parent class. This behaviour can be used to somewhat simulate constructor chaining.

<?php
abstract class Parent {
    function
__construct()
    {
        echo
"Parent constructor called\n";
       
$this->myConstruct();
    }
}

class
Child extends Parent {
    function
myConstruct()
    {
        echo
" Child 'contructor' called";
    }
}

$c = new Child();
?>

will output:
Parent constructor called
Child 'constructor' called
up
-2
dominics at gmail dot com
9 years ago
If you're using E_STRICT error reporting, PHP will tell you if you define both __construct() and an old-style constructor (a function with the same name as the class) together in a class. Note that this occurs even if the old constructor function is abstract or final (for instance, if you were intending to only use it in a sub-class). Be wary of this if you're trying to implement the 'command' design pattern.

The solution? Either turn E_STRICT off (and possibly forgo some other important notices), rename your function (and possibly make things a little more complicated), or look at using an interface.
up
-2
boukeversteeg at gmail dot com
3 years ago
Php 5.3.3 had a very strange bug, related to __destruct, but this bug was fixed in 5.3.6. This bug happened to me and it took me forever to figure it out, so I wanted to share it.

In short, don't unset properties in __destruct():
<?php
class Foobar {
    public
$baz;
    function
__destruct() {
       
# Don't do either of these, if $baz also has a __destruct()!
       
$this->baz = null;
        unset(
$this->baz);
       
       
# Instead, don't clear it at all, or do this:
       
$this->baz->__destruct();
    }
}
?>

If you made this mistake, this might happen in php<5.3.6:
<?php
# Some function that throws an exception
function fail($foobar) {
    throw new
Exception("Exception A!");
}

$foobar = new Foobar();
$foobar->baz = new Foobar();

try {
   
fail($foobar); // Send foobar to func that throws an Exception
} catch( Exception $e ) {
    print
$e->getMessage(); // Exception A will be caught and printed, as expected.
}

$foobar = null; // clearing foobar, and its property $baz

try {
    print
'Exception B:';// this will be printed
    // output stops here.
   
throw new Exception("Exception B!");
} catch(
Exception $e ) {
    print
$e->getMessage(); // doesn't happen
}
print
'End'; // this won't be printed
?>
up
-2
gratcypalma at gmail dot com
3 years ago
here is my multiple constructor.

<?php
class foo {
    protected
$mam = 'mamam';
    function
__construct() {
        echo
'foo';
    }
}
class
bar extends foo {
    function
__construct() {
       
parent:: __construct(); // use parent method to call parent class
       
echo 'bar';
    }
}
class
foobar extends bar {
    function
__construct() {
       
parent:: __construct();
        echo
'foobar';
    }
}
$show = new foobar();

/* result is foobarfoobar */
?>
up
-4
mattsch at gmail dot com
1 month ago
I would advise against the use of exceptions within __construct.  If you store the error code for an exception within a function of that class, you have no way of reading that error code to tell what type of exception it is because the object does not exist yet.

Checking the code cannot be accomplished if an exception is thrown in the construct:
<?php
class FooException extends Exception
{
}
class
Foo {
    private
$bar;
    private
$baz;
    public function
__construct($foo = null)
    {
        if (
$foo === null) {
            throw new
FooException('An error occured in construct', $this->errorConstruct());
        }
    }
    public function
setBar()
    {
       
$this->bar = 'baz';
    }
    public function
setBaz()
    {
       
$this->baz = 'foo';
    }
    final public function
errorFooNotSet()
    {
        return
1;
    }
}

try {
   
$foo = new Foo();
   
$foo->setBar();
   
$foo->setBaz();
} catch (
FooException $e) {
   
// This will error because the object doesn't exist yet
   
if ($e->getCode() == $foo->errorFooNotSet()) {
        echo
'foo is not set';
    }
}
?>

Checking the code can be accomplished if an exception is not thrown in the construct:
<?php
class FooException extends Exception
{
}
class
Foo {
    private
$bar;
    private
$baz;
    public function
__construct($foo = null)
    {
    }
    public function
init()
    {
        if (
$foo === null) {
            throw new
FooException('An error occured in construct', $this->errorConstruct());
        }
    }
    public function
setBar()
    {
       
$this->init();
       
$this->bar = 'baz';
    }
    public function
setBaz()
    {
       
$this->init();
       
$this->baz = 'foo';
    }
    final public function
errorFooNotSet()
    {
        return
1;
    }
}

try {
   
$foo = new Foo();
   
$foo->setBar();
   
$foo->setBaz();
} catch (
FooException $e) {
   
// This will work because the object does exist
   
if ($e->getCode() == $foo->errorFooNotSet()) {
        echo
'foo is not set';
    }
}
?>
up
-4
kitchin
9 months ago
If your code has a redundant constructor for PHP 4 compatibility, an E_STRICT error may be raised in PHP 5.x:

Strict Standards:  Redefining already defined constructor for class...

What is a redundant constructor for PHP 4 compatibility? It looks like
<?php
Class Foo {
  function
Foo() {
    return
$this->__construct();
  }
  function
__construct() {
   
// whatever
 
}
?>

If you don't need PHP 4, just delete the Foo function. Or you reverse the order of Foo and __construct, the error goes away, so that's probably OK for a single class. Also there was a suggestion to do this in Foo:
<?php
 
function Foo() {
    if (
version_compare(PHP_VERSION,"5.0.0","<")) {
      return
$this->__construct();
    }
  }
?>
up
-4
contact at tcknetwork dot com
9 years ago
Note that php5 use in priority __construct() instead of [classname](). So you could build a constructed/destructed class for php4/5 very easily using this.
<?
class test {
function test() {
  $this->__construct();
  register_shutdown_function(array($this,"__destruct"));
}
function __construct() {
  echo "construct\n";
}
function __destruct() {
  echo "destruct\n";
}
};
$t=new test();
?>
In case you use unset($t) in php4, the destructor is not called. so be careful.
To Top