Why Aren’t C++ Constructors Explicit by Default?

c++

It's so easy to forget to mark a constructor "explicit": adding/removing args, making them optional etc. the single reliable way I know is to declare every constructor as explicit and then remove this keyword only if implicitness is required by design (thanks to the standard that allows this not only on single-argument constructors). But this would look ugly.

not intended implicit constructors open usage of (mistaken) implicit conversion, e.g. as here. this can happen by accident, or can break backward compatibility

so why "explicit" is not default characteristic of a constructor if this would lead to fewer bugs?

p.s. yeah, I read Stroustrup's "The Design and Evolution of C++", just don't remember if he says anything about "explicit" there

Best Answer

Backward compatibility at the time when explicit was added. The language was evolving and changing meaning of existing constructs in an evolving language is a sure way to make your users angry. It is still the case now, backward compatibility is something high in the mind of the comittee.

Related Solutions

C++ Programming – Why Explicitly Call a Constructor

You also sometimes explicitly use a constructor to build a temporary. For example, if you have some class with a constructor:

class Foo
{
    Foo(char* c, int i);
};

and a function

void Bar(Foo foo);

but you don't have a Foo around, you could do

Bar(Foo("hello", 5));

This is like a cast. Indeed, if you have a constructor that takes only one parameter, the C++ compiler will use that constructor to perform implicit casts.

It is not legal to call a constructor on an already-existing object. That is, you cannot do

Foo foo;
foo.Foo();  // compile error!

no matter what you do. But you can invoke a constructor without allocating memory - that's what placement new is for.

char buffer[sizeof(Foo)];      // a bit of memory
Foo* foo = new(buffer) Foo();  // construct a Foo inside buffer

You give new some memory, and it constructs the object in that spot instead of allocating new memory. This usage is considered evil, and is rare in most types of code, but common in embedded and data structure code.

For example, std::vector::push_back uses this technique to invoke the copy constructor. That way, it only needs to do one copy, instead of creating an empty object and using the assignment operator.

C++ Constructor – Purpose of ‘explicit’ for a Default Constructor

This declares an explicit default constructor:

struct A {
  explicit A(int a1 = 0);
};

A a = 0; /* not allowed */
A b; /* allowed */
A c(0); /* allowed */

In case there is no parameter, like in the following example, the explicit is redundant.

struct A {
  /* explicit is redundant. */
  explicit A();
};

In some C++0x draft (I believe it was n3035), it made a difference in the following way:

A a = {}; /* error! */
A b{}; /* alright */

void function(A a);
void f() { function({}); /* error! */ }

But in the FCD, they changed this (though, I suspect that they didn't have this particular reason in mind) in that all three cases value-initialize the respective object. Value-initialization doesn't do the overload-resolution dance and thus won't fail on explicit constructors.

Best Answer

Related Solutions

C++ Programming – Why Explicitly Call a Constructor

C++ Constructor – Purpose of ‘explicit’ for a Default Constructor

Related Question