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构造函数