conversion constructor和cast operator function试用

试用构造函数转换(隐式)和转换操作符

#include<iostream>
using namespace std;

class A{
    public:
        A(){};//一定要有花括号表示这是个定义而不只是个声明，否则当object需要调用到这个constructor时会报错error:ld returned 1 exit status
        A(int a):value(a){
            //empty
        }
        operator int()const{
            return value;
        }
        void set(int a){
            value=a;
        }
        int get(){
            return value;
        }
    private:
        int value;
};

class B{
    public:
        B(){};
        B(double b):data(b){
            //empty
        }

        B(A aTest):data(aTest.get()){
            //empty
        }
        void set(double a){
            data=a;
        }
        operator double()const{
            return data;
        }
        operator A()const{
            A temp(data);
41             return temp;
        }
    private:
        double data;
};

void printInt(int val){
    cout<<val<<endl;
}

void printDou(double dat){
    cout<<dat<<endl;
}

void printA(const A &a){
    printInt(a);
}

void printB(const B &b){
    printDou(b);
}

int main(){
    A aTest;
65     B bTest;
    
    aTest.set(1);
68     bTest.set(3.15);
69     
    //class->fundamentle
    printInt(aTest);
72     printDou(bTest);
73     
74     cout<<endl;
75     
76     int v=3;
77     double d=4.12;
    
    //fundamental->class
    printA(v);
81     printB(d);
82     cout<<endl;
    
    //class->class
    printA(bTest);//by cast operator function
86     printB(aTest);//by constructor
87     cout<<endl;
    
    //explicit call to conversion
　　　　printA(static_cast<A>(bTest));//这一句会报错，因为编译器既可以选择constructor(隐式),也可以选择operator function，两者都不是完全匹配，都需要编译器再加一步标准转换
　　　　　　　　　　　　　　　　　　　　　　//编译器无法选择哪个更好，有二义性，所以error:call of overloaded'A(B&)'is ambiguous
　　　　　　　　　　　　　　　　　　　　　　//疑问：为什么在B的 B(A aTest)这个constructor前加一个explicit依然报错ambiguous？
    printA(bTest.operator A() );
91     printB(B(aTest));
}