Calling a PHP constructor from its own method

Question

I've been looking for a way to call a class's constructor that is analogous to "parent::_ construct" but for the class itself (something like "self:: _construct", though that doesn't work). Why do this? Consider the following (which doesn't work, btw)...

class A {
  var $name;
  function __construct($name) {
    $this->name = $name;
  }
  function getClone($name) {
    $newObj = self::__construct($name);
    return $newObj;
  }
}

class B extends A {
}

In the real implementation there are other properties that will differentiate class B from class A, but both should have the "getClone" method. If called on an object of class A it should yield another object of class A, and if called on class B it should yield another object of class B.

Of course I could do this by just overriding "getClone" in class B and hard-coding the class name into the method (ie, $newObj = new B($name)), but it would be much nicer to just code the method once, telling it to instantiate an object of its own class, whatever that class may be.

Will PHP let me do this?

Answer 1

You can use

 $clsName = get_class($this);
 return new $clsName();

But niko's solution also works, useful for a singleton pattern http://php.net/manual/en/language.oop5.static.php

Starting with php 5.3 you can use new features of the static keyword.

<?php

abstract class Singleton {

    protected static $_instance = NULL;

    /**
     * Prevent direct object creation
     */
    final private function  __construct() { }

    /**
     * Prevent object cloning
     */
    final private function  __clone() { }

    /**
     * Returns new or existing Singleton instance
     * @return Singleton
     */
    final public static function getInstance(){
        if( static::$_instance == null){
            static::$_instance = new static();
        }
        return static::$_instance;
    }
    
}
?>

Answer 2

You can use not only variables but also special class-related keywords such as "self" or "static" to create a new instance: $newObj = new static($name); - this will create a new instance of the current class.

You should probably consider using the build-in support for cloning objects: $copy = clone $instance; - you can easily extend the behavior of that operator on instances of your class by specifying a magic method __clone().

class A {
  var $name;
  function __construct($name) {
    $this->name = $name;
  }
  function getClone($name) {
    $newObj = new static($name);
    return $newObj;
  }
}

class B extends A {
}

$tmp = new A('foo');
$a = $tmp->getClone('bar');
// $a instanceof A => true, $a instanceof B => false

$tmp = new B('foo');
$b = $tmp->getClone('bar');
// $b instanceof A => true, $b instanceof B => true

Answer 3

What you want to do is use the built in object cloning functionality http://php.net/manual/en/language.oop5.cloning.php

But for your direct question about recalling constructor, what you should do is make an init() function, and put all of your __constructor code in init() and have __constructor call init()