static_cast Conversion constructor vs Conversion operator [duplicate]

Question

After reading this I tried making such conversion with static_cast:

class A;

class B { 
      public: 
         B(){} 

         B(const A&) //conversion constructor
         { 
              cout << "called B's conversion constructor" << endl; 
         } 
};

class A { 
      public: 
         operator B() const //conversion operator
         { 
              cout << "called A's conversion operator" << endl; 
              return B(); 
         } 
};

int main()
{
    A a;

    //Original code, This is ambiguous, 
    //because both operator and constructor have same cv qualification (use -pedantic flag)
    B b = a;

    //Why isn't this ambiguous, Why is conversion constructor called, 
    //if both constructor and  operator have same c-v qualification
    B c = static_cast<B>(a); 
    return 0;
}

I expected it to not compile, because both constructor and operator have same c-v qualification. However it compiled, successfully and static_cast calls constructor instead of operator. Why?

(compiled using gcc 4.8.1 with pedantic and Wall flags)

Answer 1

The C++11 Standard says (emphasis mine):

5.2.9 Static cast

4 Otherwise, an expression e can be explicitly converted to a type T using a static_cast of the form static_cast<T>(e) if the declaration T t(e); is well-formed, for some invented temporary variable t (8.5). The effect of such an explicit conversion is the same as performing the declaration and initialization and then using the temporary variable as the result of the conversion. The expression e is used as a glvalue if and only if the initialization uses it as a glvalue.

5 Otherwise, the static_cast shall perform one of the conversions listed below. No other conversion shall be performed explicitly using a static_cast.

That explains why the static_cast in

B c = static_cast<B>(a); 

ends up calling the constructor of B.

The conversion operator is used only if the T t(e) is not well-formed.