自己转换为别的类型
做法：使用operator关键字，无需返回值，函数名称就是返回值。如有需要加上const修饰。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Class A { Public: A(int arg1, int arg2) : x(arg1), y(arg2) {} operator double() const { return (double)(x/y); } private: int x; int y; }
non-explicit-one-argument ctor
本质是编译器将别的对象转化为我们定义的对象
要求的自定义构造函数比较特殊
在实例代码中编译器会把4装换为A，然后执行+ 操作。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Class A { Public: A(int arg1, int arg2) : x(arg1), y(arg2) {} A operator +(const A& a) { return A(....); } private: int x; int y; } A a(2,3); double d = a + 4;
编译器有时会不清楚 -下面的代码中a+4时编译器发现可以用double操作，也可以用+操作，在这样的情况下编译器会不知道如何选择进而报错。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 Class A { Public: A(int arg1, int arg2) : x(arg1), y(arg2) {} A operator +(const A& a) { return A(....); } operator double() const { return (double)(x/y); } private: int x; int y; } A a(2,3); double d = a + 4;
explicit-one-argument ctor
explicit关键字几乎都是用到构造函数前面的，告诉编译器不要随便的把别的类型转换为我自定的类型。
下面的例子中，编译器不会再把4转成A，因此这个表达式是错误的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Class A { Public: explicit A(int arg1, int arg2) : x(arg1), y(arg2) {} A operator +(const A& a) { return A(....); } private: int x; int y; } A a(2,3); double d = a + 4;