Think_in_CPP第十二章 操作符重载(7)

12.11 自动类型转换(Automatic type conversion)

#include <iostream> using namespace std; class One { public:    int i;    One() { i=1; cout << "One" << i<< endl;} }; class Two {         int i; public:    Two(const One& a) { i=2;cout << "Two" << i << a.i << endl;} }; void f(Two) {} int main() {    One one;    f(one); // Wants a Two, has a One } 

输出结果

       One1
       Two21

可以看到Two的构造函数被调用，传入的参数是一个One对象。也就是自动类型转换发生了。发现当前类型不是所需要类型的时候，编译器试图寻找可以生成需要类型的方法。在上面的例子中需要Two类型，但是传入的是One，编译器发现Two的有一个只有一个参数构造函数，其参数类型为One于是，类型转换发生了。

要求：
1)构造函数有一个参数，且为被转换对象所属类型
2)构造函数除了被转换对象所属类型作为其中一个参数外，还有其他参数，且都提供了默认值
3)不能建立基于构造函数的用户定义类型到内建类型的自动转换，只能通过操作符重载这一方式

阻止基于构造函数的自动类型转换
方法是在构造函数前面加上关键字：explicit

class One { public:    One() {} }; class Two { public:    explicit Two(const One&) {} }; void f(Two) {} int main() {    One one; //! f(one); // No auto conversion allowed    f(Two(one)); // OK -- user performs conversion } 

通过操作符重载来实现类型自动转换(Operator conversion)

class Three {   int i; public:   Three(int ii = 0, int = 0) : i(ii) {} }; class Four {    int x; public:    Four(int xx) : x(xx) {}    operator Three() const { return Three(x); } }; void g(Three) {} int main() {    Four four(1);    g(four);    g(1); // Calls Three(1,0) } 

要点：
1)作为类的成员函数
2)形式：operator 目标类名()
3)在使用的时候，传入一个Four对象，但是需要的是Three对象，而Four类又有一个可用于类型转换的操作符重载函数，这个时候转换发生

Reflexivity
通过一个例子来说明成员函数方式和全局函数方式的差别

class Number {   int i; public:    Number(int ii = 0) : i(ii) {}    const Number    operator+(const Number& n) const {      return Number(i + n.i);    }    friend const Number      operator-(const Number&, const Number&); }; const Number    operator-(const Number& n1,              const Number& n2) {      return Number(n1.i - n2.i); } 

int main() {    Number a(47), b(11);    a + b; // OK    a + 1; // 2nd arg converted to //! 1 + a; // Wrong! 1st arg not    a - b; // OK    a - 1; // 2nd arg converted to    1 - a; // 1st arg converted to } 

成员函数方式要求左值必须是确定的类型，不能通过自动转换方式得到。所以1+a处编译错误。而全局函数方式则没有这个限制1-a处，1就自动转成了需要的类型

有些时候利用类型转换的特性可以带来编码的便利

#include "../require.h" #include <cstring> #include <cstdlib> #include <string> using namespace std; class Stringc {   string s; public:   Stringc(const string& str = "") : s(str) {}   int strcmp(const Stringc& S) const {     return ::strcmp(s.c_str(), S.s.c_str());   } };  

int main() {    Stringc s1("hello"), s2("there");    s1.strcmp(s2); }

利用类型转换特性加以改造

#include "../require.h" #include <cstring> #include <cstdlib> #include <string> using namespace std; class Stringc {    string s; public:    Stringc(const string& str = "") : s(str) {}    operator const char*() const {      return s.c_str();    } }; 

int main() {    Stringc s1("hello"), s2("there");    strcmp(s1, s2); // Standard C function    strspn(s1, s2); // Any string function! } 

自动类型转换的陷阱
自动类型转换要注意一些问题：如一个类型到另外一个类型有1种以上的转换路径；或者是和重载函数一同使用时要转换的目标类型模糊等

class Orange; // Class declaration class Apple { public:    operator Orange() const; // Convert Apple to Orange }; class Orange { public:    Orange(Apple); // Convert Apple to Orange }; void f(Orange) {} int main() {    Apple a; //! f(a); // Error: ambiguous conversion } ///:~

问题：有两种Apple->Orange的方式
解决办法1：

class Orange {}; class Pear {}; class Apple { public:    operator Orange() const;    operator Pear() const; }; void eat(Orange); void eat(Pear); int main() {    Apple c; //! eat(c);    // Error: Apple -> Orange or Apple -> Pear ??? }

解决办法2：可以提供转换函数

class Fi {}; class Fee { public:    Fee(int) {}    Fee(const Fi&) {} }; class Fo {    int i; public:    Fo(int x = 0) : i(x) {}    operator Fee() const { return Fee(i); } };  

int main() {   Fo fo;   Fee fee = fo; }

发生了如下事情：
1)Fo的操作符重载函数调用，返回一个Fee对象
2)Fee没有定义copy构造函数，采用默认的copy构造函数