Why can't constructors be explicitly called while destructors can?

Question

In the following C++ code, I am allowed to explicitly call the destructor but not the constructor. Why is that? Wouldn't be explicit ctor call more expressive and unified with the dtor case?

class X { };

int main() {
  X* x = (X*)::operator new(sizeof(X));
  new (x) X;  // option #1: OK
  x->X();     // option #2: ERROR

  x->~X();
  ::operator delete(x);
}

Answer 1

Because before the constructor is started, there is no object of type X at that address. As such, dereferencing x as an X type or accessing members/methods of it would be Undefined Behavior.

So the major difference between x->X(); (hypothetical syntax) and x->~X() is that in the 2nd case you have an object on which you can call a (special) member such as the destructor, while in the first case, there is no object yet on which you can call methods (even the special method - constructor).

You could argue that there could be an exception to this rule, but then it ultimately would be a matter of syntax preference, where you have inconsistencies in both cases. With the current syntax the call to constructor doesn't look like a call to constructor, in your proposed syntax there would be symmetry with the destructor call, but inconsistencies in the rules which govern when you can dereference/access methods of an object. Actually there would have to be an exception allowing calling a method on something that is not a object yet. Then you would have to strictly define in the letter of the standard something that is not an object yet.

Answer 2

This is a variation of the chicken-and-egg problem.

You can call destructors explicitly, as if they were member functions, because the instance of the object already exists.

You cannot do the same to a constructor, because an instance on which you would call it needs to exist, and be fully initialized by a constructor.

The only exception to this is when you have allocated memory for the object, but have not yet initialized the instance (i.e. the memory for the instance is there, but it has not been initialized to become an actual instance). Hence, you need to call a constructor. This is the situation when placement new, the syntax you show under "option 1" comment, is useful. However, this is not a member call that you perform on an instance, because the instance is not available prior to making that call.