How explicit is implemented internally in C++

explicit just tells the compiler to "don't use that constructor to translate implicit conversion".

In case an implicit conversion is required, the compiler will simply look for another suitable function (like a Class::operator Type())

The function itself is not "different". no so effert will go in the translated code.

Note that the explicit keyword has a clue only in constructor that can take only one argument, since are the ones used in conversions.

It's implemented somewhere in the compilers front end, it doesn't get anywhere near the code generator and I'm fairly sure it doesn't play any part in overload resolution.

You can see this by defining two different versions of a class in two different translation units, the only difference being the use of explicit. So in one:

class A
{
    public:
        explicit A();
};

and in the other:

class A
{
    public:
        A();
};

and use both definitions of the class in their respective translation units.

You can then implement both versions in a third translation unit:

class A
{
    public:
        A();
};

A::A()
{
}

and hey presto the implementation will satisfy both explicit and non-explicit uses in either of the other two translation units. Incidentally you can do the same trick with public, protected and private.

So what does this mean? As far as I can tell it means no information about whether a constructor is marked explicit ends up in the object file along with it's implementation.

I may be wrong though, your compiler may vary. Don't rely on it in production code.

Cheers,

Ash