Object 2 1

PHP5 Tutorial Magic Methods __clone() method

Before I begin to explain the use of a __clone() method, lets try and understand what does object cloning mean. To clone an object means to create a duplicate of an object. With regular variables $a = $b means that a new variable $a gets created that contains the value of $b. This means that 2 variables get created. With objects $obj2 = $obj1 does not mean that a new object i.e. $obj2 gets created. When we execute $obj2 = $obj1, the reference of $obj1 is assigned to $obj2. This means that $obj1 and $obj2 point to the same memory space. Look at the diagram below.

Lets look at an example where only references are assigned to another object:
class Customer { private $name; public function setName($name) { $this->name = $name; } public function getName() { return $this->name; }

$c1 = new Customer(); $c1->setName("Sunil"); $c2 = $c1; //only reference or memory assigned to $c2 $c2->setName("Vishal"); echo $c1->getName()."\n"; echo $c2->getName()."\n";

Output: Vishal Vishal In the above example, $c2 has the reference of $c1; therefore, when you set a new name in the $c2 object $c1 object changes as well. Therefore, when an object is assigned as a reference; changes made to one object are also reflected in the other. Therefore, to create a new $obj2 object we must clone an object to create a new one. To clone an PHP5 Object a special keyword i.e. clone is used. Example below:
$obj2 = clone $obj1;

After the above line is executed $obj2 with a new memory space is created with the data members having the same value as that of $obj1. This is also referred to as shallow copy.

The above technique works with a class having data members that are of intrinsic type i.e. int, boolean, string, float, etc.. However, this technique will not work with a class that has a data member which is an object of another class. In such a scenario, the cloned object continues to share the reference of the data member object of the class that was cloned. So, how do we resolve this issue? Doing a regular shallow copy wont help us. To allow aggregated objects (i.e. data members that are objects of another class) to also get cloned properly we need to use the concept of deep copy as opposed to shallow copy. To implement a deep copy you should implement the magic method __clone(). You could also provide the implementation of __clone() magic method even when you dont have an aggregated object. You would want to do this for providing necessary clean up operations, conversions or validations. Lets explore a very simple example of cloning intrinsic data types:
class Customer { private $name; public function setName($name) { $this->name = $name; } public function getName() { return $this->name; } public function __clone() { $c = new Customer(); $c->setName($this->name); return $c; } } $c1 = new Customer(); $c1->setName("Sunil"); $c2 = clone $c1; //new object $c2 created $c2->setName("Vishal"); echo $c1->getName()."\n"; echo $c2->getName()."\n";

Output: Sunil Vishal In the above example, observe the line where the statement $c2 = clone $c1 is executed.

This is internally represented as $c2 = $c1.__clone(). However, you cannot explicitly call the __clone() method on an object as the __clone() is automatically called. Now that $c1 and $c2 are two individual objects, changes made to one object is not reflected in the other.

Cloning aggregate objects (i.e. data members that are objects of another class) To clone a class having aggregated objects, you should perform deep copy. Please refer to the example below:
class Order { private $order_id; private $customer; public function setOrderId($order_id) { $this->order_id = $order_id; } public function getOrderId() { return $this->order_id; } public function setCustomer(Customer $customer) { $this->customer = clone $customer; } public function getCustomer() { return $this->customer; } public function __clone() { $o = new Order(); $o->setOrderId($this->order_id);

} }

//force a copy of the same object to itself, otherwise //it takes the same instance. Seems like a bug to me $this->customer = clone $this->customer; $o->setCustomer($this->customer); return $o;

class Customer { private $name; public function setName($name) { $this->name = $name; } public function getName() { return $this->name; }

public function __clone() { $c = new Customer(); $c->setName($this->name); return $c; } } $c = new Customer(); $c->setName("Sunil"); $o1 = new Order(); $o1->setOrderId("OD0001"); $o1->setCustomer($c); $o2 = clone $o1; $o2->getCustomer()->setName("Vishal"); var_dump($c); var_dump($o1); var_dump($o2);

Output: object(Customer)#1 (1) { [name:private]=> string(5) Sunil } object(Order)#2 (2) { [order_id:private]=> string(6) OD0001 [customer:private]=> object(Customer)#3 (1) { [name:private]=> string(5) Sunil } } object(Order)#4 (2) { [order_id:private]=> string(6) OD0001 [customer:private]=> object(Customer)#6 (1) { [name:private]=> string(6) Vishal } } In the above example both $o1 and $o2 have their own set of customer objects, therefore changes made to one object is not reflected in another. This example implements the concepts of deep copy. A special note on $this->customer = clone $this->customer; For some reason it is necessary

to do this for proper working of aggregated cloning. I hope this tutorial was helpful. Please feel free to leave behind any comments or questions that you might have.