《More Effective C++》学习心得（四） 关于类中类型转换

#include <iostream>
using namespace std;
// example1:单参数构造函数可将内建类型转换为自建的类类型
class A
{
public:
A(double i=0.0){d=i;}
void print()
{
cout<<"d="<<d<<endl;
}
~A(){cout<<d<<"析构"<<endl;}
protected:
private:
double d;
};
// example2:operator 目的类型(){}可见类对象隐式转换为指定的类型
class B
{
public:
B(double i){d=i;}
operator double()
{
return d;
}
~B(){cout<<d<<"析构"<<endl;}
protected:
private:
double d;
};
void main()
{
A a;
a=3.693;
a.print();
B b(9.23);
cout<<b<<endl;
}

输出的结果：

3.693析构（3.693先生成一个A的临时对象，转换后对象销毁）

d=3.693

9.23

9.23析构

3.693析构（堆栈式销毁：后进先出）

《More Effective C++ 》中认为要避免这样的隐式类型转换：分别有对应的解决方法，如下

#include <iostream>
using namespace std;
// example1:单参数构造函数可将内建类型转换为自建的类类型
class A
{
public:
explicit A(double i=0.0){d=i;}//使用explicit解决隐式类型转换的问题
void print()
{
cout<<"d="<<d<<endl;
}
~A(){cout<<d<<"析构"<<endl;}
protected:
private:
double d;
};
// example2:operator 目的类型(){}可见类对象隐式转换为指定的类型
class B
{
public:
B(double i){d=i;}
double asDouble() //避免类型转换的方法
{
return d;
}
~B(){cout<<d<<"析构"<<endl;}
protected:
private:
double d;
};
void main()
{
A a;
//	a=3.693;    //it's wrong
a=static_cast<A>(3.693);//强制类型转换
a.print();
B b(9.23);
//	cout<<b<<endl;//it's wrong
cout<<b.asDouble()<<endl;

}

以下是proxy class的用法，也能避免隐式的类型转换

#include <iostream>
using namespace std;
// example1:单参数构造函数可将内建类型转换为自建的类类型
// 方法1：使用explicit
// 方法2：使用proxy class
//这里演示方法2
class A
{
public:
class Avalue
{
public:
Avalue(double d1=0){dd=d1;};
double value(){return dd;};
private:
double dd;
};
A(Avalue aobj){d=aobj.value();}
void print()
{
cout<<"d="<<d<<endl;
}
~A(){cout<<d<<"析构"<<endl;}
protected:
private:
double d;

};

void main()
{
A a(2.4);//这是可行
a=2.4;   //it's wrong。
a.print();

}