1.1.5.4 Implicit conversion

• Compiler will first match fun name and argument, then look for template deducted function, then use implicit conversion to try match. So implicit conversion happens the last in fact .
• When and How implicit conversion happen:
  1. assignment
  2. other operator
  3. fun call and return
• Implicit conversion sometimes will lead to potential ambiguity problem.
  class A{ 
  A(class B&); 
  }; 
  class B{ 
  operator A() 
  }; 
   
  void g(const A&); 
  B b; 
  g(b) // it can call ctor 
         // or it can call opeartor A() in class B 
  //compiler will stop, it meet ambiguity.

  more detail can be seen effective c++ item 26.

• For class, there are three possible implicit conversion: 1) single ctor 2)operator build-in-type() 3) assignment operator()
  class A {}; 
   
  class B { 
  public: 
    // conversion from A (constructor): 
    B (const A& x) {} 
   
    // conversion from A (assignment): 
    B& operator= (const A& x) {return *this;} 
   
   
    // conversion to A (type-cast operator) 
    operator A() {return A();} 
  }; 
   
    void fun(B x){}; 
   
    A foo; 
    B bar = foo;    // calls constructor 
    bar = foo;      // calls assignment 
    foo = bar;      // calls type-cast 
    fun(foo)    //change foo to temp bar, bad smell code here.
• Declare single-parameter ctor as explicit. Or it will easy to occur implicit conversion. For example,
  class Foo{ 
  Foo(int a);  // or explicit Foo(int a); 
  operator*( Foo & f); 
  Foo& operator=(const Foo &); 
  } 
   
  /.cpp file 
  Foo foo foo1; 
  foo1 = foo*2;  //implicit conversion 2 to temp Foo obj 
  foo1 = 2  the same, then call operator =;
• in order to avoid this implicit conversion, you can add explicit in front of constructor function. With explicit keyword, you can use Foo(19) or (Foo)19 to explicitly build a Foo obj.
• convert class to basic type, you need operator basicTypeName, no argument, no return value. member function. double d = double(class)
• These cast can be called by compiler implicit, (means that you don’t know at all). Sometimes it’s quite dangerous. single argument ctor will happen implicit conversion, just bad smell code in previous example, A good solution is use explicit keyword to qualify the single argument ctor. operator build-in-type is not good either, so string has function c_str() instead operator char*() const. So just use explicit when you define single argument ctor and operator build-in-type.