How do you pass objects by reference in PHP 5?

In PHP 5, objects are automatically passed by reference, meaning that when you pass an object to a function or assign it to another variable, you're working with the same object instance, not a copy.

Understanding Object References

A PHP reference is an alias that allows two different variables to point to the same value. In PHP 5, object variables don't contain the actual object − they hold an object identifier that points to the object in memory.

When an object is passed as an argument, returned, or assigned to another variable, these variables contain a copy of the identifier pointing to the same object.

Example

Here's how object references work in practice −

<?php
class MyClass {
    public $value = 10;
    
    public function setValue($newValue) {
        $this->value = $newValue;
    }
}

// Create an object
$obj1 = new MyClass();
echo "Initial value: " . $obj1->value . "<br>";

// Assign to another variable
$obj2 = $obj1;

// Modify through the second variable
$obj2->setValue(20);

// Both variables show the same change
echo "obj1 value: " . $obj1->value . "<br>";
echo "obj2 value: " . $obj2->value . "<br>";
?>

Initial value: 10
obj1 value: 20
obj2 value: 20

Passing Objects to Functions

When you pass objects to functions, they're automatically passed by reference −

<?php
class Counter {
    public $count = 0;
    
    public function increment() {
        $this->count++;
    }
}

function modifyObject($obj) {
    $obj->increment();
    $obj->increment();
}

$counter = new Counter();
echo "Before function: " . $counter->count . "<br>";

modifyObject($counter);
echo "After function: " . $counter->count . "<br>";
?>

Before function: 0
After function: 2

Key Points

In PHP 5, this behavior is called "assignment by reference" rather than "pass by reference". Objects are automatically handled by reference, so you don't need to use the & operator explicitly.

Conclusion

PHP 5 automatically passes objects by reference, meaning all variables pointing to an object share the same instance. This eliminates the need for manual reference operators when working with objects.