#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();
}