explicit.cpp

/*
# explicit keyword

    Keyword specifies that a given constructor can only be used explicitly.
*/

#include "common.hpp"

class Implicit {
    public:
        int i;
        Implicit(int i) : i(i) {}

        operator int() {
            return this->i;
        }
};

class Implicit2 {
    public:
        int i;
        Implicit2(Implicit i) : i(i) {}
};

class Explicit {
    public:
        int i;

        explicit Explicit(int i) : i(i) {}

        // TODO this makes no sense right, since it is not a ctor that takes a single arg?
        // why does it compile without warning
        explicit Explicit(int i, int j) : i(i + j) {}

        // ERROR: only for constructors and conversion functions since C++11.
        //explicit void method(){}

#if __cplusplus >= 201103L
        explicit operator int() {
            return this->i;
        }

        // Cannot do this test here as the `int i = o` would then use it.
        //operator float() {
            //return (float)this->i;
        //}
#endif
};

int main() {
    // Without implicit, the cast is made with the constructor that takes one argument.
    {
        Implicit o = 1;
        assert(o.i == 1);
    }

    // ERROR: Only a single cast can be made.
    //{ Implicit2 o = 1; }
    {
        Implicit2 o = Implicit(1);
        assert(o.i == 1);
    }

    // ERROR: explicit prevents implicit casts.
    //{ Explicit o = 1; }

    // Explicit casts are still allowed.
    {
        Explicit o = (Explicit)1;
        assert(o.i == 1);
    }

    // Operator
    {
        {
            Explicit o(1);
            // ERROR
            //int i = o;
        }

        {
            Explicit o(1);
            int i = (int)o;
        }

        {
            Implicit o(1);
            int i = o;
            assert(i == 1);
        }
    }
}