《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();


}