c++允许编译器在不同类型之间执行隐式转换,方法有两种:单自变量构造函数和隐式类型转换操作符。
单自变量构造函数:可能声明拥有单一参数,也可能声明拥有多个参数,并且除了第一参数之外都有默认值。
class Name
{
public:Name(const string& s);
};class Rational
{
public:Rational(int numerator = 0, int denominator = 1);
};
隐式类型转换操作符:关键词operator之后加一个类型名称。
class Rational
{
public:operator double() const;
};
这个函数会在下面情况被调用,第二行的r会被隐式转化为double类型:
Rational r(1, 2);double b = 0.5 * r;
为什么最好不要提供任何类型转换函数,根本问题在于,在你从未打算也未预期的情况下,此类函数可能会被调用,而其结果可能是不正确、不直观的程序行为,很难调试。
例子1:
Rational r(1,2);
cout<<r<<endl;//应该输出1/2
假设你忘记为这个Rational写一个operator<<,你可能希望在调试或者运行的时候报错,但是事实上并没有报错。当编译器发现不存在任何operator<<可以接受Rational,它会想尽办法让这个参数调用成功。比如调用Rational::operator double(),将r隐式转化为double,这样上述cout会以浮点数方式将r输出。
解决方法,就是用函数取代类型转换操作符。比如:
class Rational
{
public:double asDouble() const;
};
用成员函数明确调用:
Rational r(1,2);
cout<<r;//错误,Rational 没有 operator<<
cout<<r.asDouble();
标准程序库的string类型并未含有“从string object到C-style char *的隐式转换函数”,他们提供的办法是用一个显式的成员函数string.c-str()来执行上述行为。
例子2:
template <class T>
class Array
{
public:Array(int lowBound, int highBound);Array(int size);T& operator[](int index);};
bool operator==(const Array<int> &lhs, const Array<int> &rhs);int main ()
{Array<int> a(10);Array<int> b(10);for (int i = 0; i < 10; i++){if (a == b[i]){//do something}else{//do something}}return 0;
}
主函数里面应该是a[i]==b[i],但是忘记写[i],此时编译器并没有报错。它会同过调用Array::Array(int size)将b[i]隐式转换为Array,然后每次迭代都用a的内容和这个数组比较。这不仅没有实现功能,并且很没有效率,因为必须产生和销毁这个临时变量。
解决办法:
使用C++特性:关键词explicit。只要将构造函数声明为explicit,编译器便不能因隐式转换而调用他们,不过显式转换还是允许的;
template <class T>
class Array
{
public:Array(int lowBound, int highBound);explicit Array(int size);T& operator[](int index);};
bool operator==(const Array<int> &lhs, const Array<int> &rhs);
int main()
{Array<int> a(10);Array<int> b(10);if (a == b[0])//不行,无法隐式转换{}if (a == Array<int>(b[0]))//可行,显示调用构造函数{}if (a == static_cast<Array<int>>(b[0]))// c++类型转换函数,可行,但是功能让人怀疑{}if (a == (Array<int>) (b[0]))//c旧式转型可行,但是功能让人怀疑{}
return 0;
}
下面,再次考虑Array template,你需要一种方法,不但允许以一个整数作为构造函数自变量指定数组大小,又能阻止一个整数被隐式转换为一个临时Array变量。
template <class T>
class Array
{
public:class ArraySize{public:ArraySize(int numElements) :theSize(numElements){}int size() const { return theSize; }private:int theSize;};Array(int lowBound, int highBound);explicit Array(ArraySize size);T& operator[](int index);};
当我们运行下面代码时:
Array<int> a(10)
编译器先将int转为临时的ArraySize变量,再调用构造函数。
但是如果运行下面代码:
Array<int> a(10);
Array<int> b(10);
for (int i = 0; i < 10; i++)
if (a == b[i])
{}
上面a==b[i]是无法成功的。编译器不能考虑现将int转换为临时的ArraySize对象,再产生Array对象,因为隐式转换只会调用一次。
为什么最多只能调用一次隐式转换?
①编码人员更容易出错了,代码检查困难。
②如果需要A→D,但是有多种途径,那是从A→B→D还是A→C→D呢,可能是不一样的。
③一次转换就让人头疼了,所以explicit关键字都出来了,人们更倾向于显式类型转换。
④编辑器&编译器更复杂啊喂,类型检查难度大增。
⑤如果允许了2次,你还会问为什么不允许3次?