In PHP, is it possible to create an instance of an class without calling class's constructor?

In your case I would recommend to think about redesigning your code so you don't need to do such a things, but to answer you question: yes, it is possible.

You can use ReflectionClass and it's method newInstanceWithoutConstructor introduced in PHP 5.4 Then it's very easy to create an instance of a class without calling its constructor:

$reflection = new ReflectionClass("ClassName");
$instance = $reflection->newInstanceWithoutConstructor(); //That's it!

Note: The solution below is for PHP 5.3 and below. As of PHP 5.4, you can also do it via Reflection as shown elsewhere on this page.

This is indeed possible.

Modified from PHPUnit_Framework_MockObject_Generator

1  $myClass = unserialize(
2      sprintf(
3          'O:%d:"%s":0:{}',
4          strlen('MyClass'), 'MyClass'
5      )
6  );

Please keep in mind, that code like this is all good and justified in a framework like PHPUnit. But if you have to have code like this in your production code, you are likely doing something very odd.

Since you asked for an explanation:

When you serialize an Object you get a string representation of the object. For instance

echo serialize(new StdClass) // gives O:8:"stdClass":0:{}

The O means object. 8 is the string length of the class name. "stdClass" is obviously the class name. The serialized object has 0 properties set (more to that later), indicated by the empty curly braces. The : are just delimiters.

Every serialized string can be recreated into its original "live" value with the unserialize function. Doing so, will circumvent the constructor. Like Charles correctly pointed out the magic method __wakeup() will be called if it is defined (just like __sleep() will be called when serializing).

In Line 3 you see a string prepared to be used with sprintf (line 2). As you can see the string length of the class name is given as %d and the class name is given as %s. This is to tell sprintf that it should use the first argument passed to it in line 4 as a digit and the second as a string. Hence, the result of the sprintf call is

'O:7:"MyClass":0:{}'

You would replace both occurences of "MyClass" in line 4 with your desired class name to create a serialized string of the class you want to instantiate without invoking the controller.

This string is then unserialized into a MyClass instance in line 1, bypassing the constructor. The unserialized instance will have all the methods of it's class and also any properties. If there is properties in MyClass, these will have their default values, unless you add different values to the serialized dummy string.

And that's already it. Nothing too magical about it.

Wouldn't it be better to make the function you need static - alter class A so that it has another constructor that doesn't take any aruguments

If a class has a function that doesn't access any of the non static properties or functions in a class it can be made static.

class A{
    public function __construct($arg1){
    }

    public static function foo(){
        //do something that doesn't involve the class properties
    }
}

It can then be called without having to construct the class

//the constructor will not be called as we haven't created an instance of A
A::foo();

The difference between a static and a none static function is that the static function cannot access class properties of functions that are also static. So if in foo() you have any code that uses $this-> you can't make it static.

Would something like this work?

class User{

  private $db;

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

  public function getUser(){
    return $this->db->query("select * from user where id = '123' limit 1");
  }

  public static function getInstance(){
    $db = new Database();
    return new User($db);
  }
}

class Other{

  public function getUser(){
    $class = User::getInstance();
    return $class->getUser();
  }
}

you could make the method static and call it from class context and not object context.

in code it would look like this:

class A {
  public static function func($txt) {
    print($txt);
  }
}

A::func('test');