Too few arguments error even though argument passed properly

Question

When I run this, it complains that

Too few arguments to function Base::__construct(), 0 passed in [FileName].php on line 18 and exactly 1 expected

class Base {
    protected $var;
    public function __construct($var){
        $this->var = $var;
    }
}

class ChildA extends Base {
    public function handle(){
        echo $this->var;
    }
}

$base = new Base(10);

(new ChildA())->handle();

But as you can see, I have passed: $base = new Base(10);

Edit: As mentioned in answers and comments, the problem was not in here:

$base = new Base(10);

...but here:

(new ChildA())->handle();

What am I doing wrong? Also, what I am trying to achieve is that, there are many ChildX classes who need to extend Base and all these child classes must have the $var property. So, Instead of duplicating the $var in each child classes, I wanted to reduce typing effort by putting it in a parent class. But apparently, my plan didn't work out.

Answer 1

Your problem is actually this line:

(new ChildA())->handle();

Do this instead:

$child = new ChildA(10);
$child->handle();

You don't need to instantiate the base class separately.

One other thing. When both parent and child classes have a constructor, you can put parent::__construct($whatever); in the child's constructor to run the parent code also.

Answer 2

This is a simple concept of class instantiation, I think which you are getting it wrong.

When you did

$base = new Base(10);

you are creating an instance of the Base class only.

However, the following statement invokes another instance of the Child class. Note, the base variable and this child instance are two different entities, hence their behaviour will not impact each other.

(new ChildA())->handle();

So, currently base variable will have a value of 10, but the handle() function call cannot be instantiated since it requires an argument which is to be supplied to the new instance of the Base class.

You'll need to instantiate the child class, due to which the constructor of the inherited class will be called first and your variable will be set. Your handle() function can then successfully return the correct value.

$child = new Child(10); $child->handle(); //returns 10

Answer 3

When you extend a class, all the methods on that class exist on the child class by default, including "magic" methods like __construct.

So when you write this:

class Base {
    protected $var;
    public function __construct($var){
        $this->var = $var;
    }
}

class ChildA extends Base {
    public function handle(){
        echo $this->var;
    }
}

Your child class actually looks something like this:

class ChildA extends Base {
    // Inherited property from Base class
    protected $var;

    // Inherited method from Base class
    public function __construct($var){
        $this->var = $var;
    }

    // New method in this class
    public function handle(){
        echo $this->var;
    }
}

This is a slight simplification, as we'll see below, but it explains what happens in your example:

$base = new Base(10);

$base is an instance of the Base class; it is completely separate from any other instance of that class, and from any instance of the ChildA class.

(new ChildA())->handle();

This attempts to run the __construct method in the ChildA class; the copy of that method inherited from Base requires an argument, but you didn't supply one, so you get an error. It is expecting you to call it like this:

(new ChildA(10))->handle();

If we define __construct directly in the child class, we can give it a different number of arguments:

class ChildB extends Base {
    public function __construct() {
        // Do nothing
    }
    public function handle(){
        echo $this->var;
    }
}
(new ChildB())->handle();

But now we have a different problem: the logic in the Base class isn't running, so $this->var is never set to anything.

This is where I over-simplified things above. In reality, the parent __construct method and child __construct method both exist, they just "hide" each other. You can access the parent copy with the syntax parent::method.

So you can make a child class, with a constructor which takes no arguments, and when that constructor is run, run the base constructor with a hard-coded value of 10:

class ChildC extends Base {
    public function __construct() {
        // Run the constructor in the Base class
        parent::__construct(10);
    }
    public function handle(){
        echo $this->var;
    }
}
(new ChildC())->handle();

Answer 4

Your new ChildA() is calling constructor from Base and you are not passing any arguments here.

You make mistake here: when you do new Base(10) your $var is not passed to new instance of new ChildA()

In your case I would use static parameter instead of constructor value

class Base {
    protected static $var;

    public function __construct(){
    }

    public static function setVar($var) {
        self::$var = $var;
    }
}

class ChildA extends Base {
    public function handle(){
        echo self::$var;
    }
}

Base::setVar(10);

(new ChildA())->handle();