'Explicit' Keyword and Implicit Conversions

struct Foo{   Foo(int) {};};void Func(Foo) {};Func(23);      // Implicit conversion from int to Foo via Foo(int)Func(Foo(23)); // Equivalent

struct Foo{   explicit Foo(int) {};};void Func(Foo) {};Func(23);      // Flagged as an errorFunc(Foo(23)); // Works

struct Foo{   Foo(int) {};};struct Bar{   Bar(Foo) {}};void Func(Bar) {};Func(23);      // Error, requires two implicit user-defined conversions.Func(Foo(23)); // Works, only one implicit conversion.

struct Foo{   Foo(double) {};};void Func(Foo) {};Func(true);    // Ok bool -> int -> double -> Foo

struct Foo{   Foo(int) {};};void Func(Foo) {}void Func(double) {}Func(5);  // Calls Func(Foo), Foo(int) is a better match than Func(double)

struct Foo;struct Bar{   Bar() {};   Bar(Foo);};struct Foo{   operator Bar() { return Bar(); }};Bar::Bar(Foo) {}void Func(Bar) {};int main(){  Func(Foo()); // Error, use Bar::Bar(Foo) or Foo::operator Bar() ?}

struct Foo;struct Bar{   Bar() {};   explicit Bar(Foo);};struct Foo{   operator Bar() { return Bar(); }};Bar::Bar(Foo) {}void Func(Bar) {};int main(){  Func(Foo()); // Will use Foo::operator Bar();}

struct Foo{   explicit Foo(int) {};};void Func(Foo) {}void Func(double) {}Func(5);      // Calls Func(double)Func(Foo(5)); // Calls Func(Foo)

struct Foo{   Foo(int);   Foo(double);};Foo operator+(const Foo&, const Foo&); // (A)Foo operator+(int, const Foo&);        // (B)Foo operator+(const Foo&, int);        // (C)Foo f;f = f+5;   // calls (C) operator+(f, 5);        -> no temporaryf = f+5.0; // calls (A) operator+(f, Foo(5.0)); -> temporary

struct Foo{   Foo(int) {}};struct Bar{   explicit Bar(int) {};};Foo f = 5; // OK.Foo g(5);  // OK.Bar b = 5; // Boom.Bar c(5);  // OK.