class Demo
{
public:
Demo()
{}
Demo(int j)
{
cout<<"Demo int: "<<j<<endl;
this->i = j;
}
Demo(const Demo& d)
{
cout<<"复制构造函数"<<endl;
}
Demo& operator = (const Demo& d)
{
cout<<"operator ="<<endl;
this->i = d.i;
return *this;
}
int i;
};
int main()
{
Demo demo1;
Demo demo2 = demo1; //当我们使用一个对象来初始化另一个对象时,编译器将自动生成等效语句:Demo demo2 = Demo(demo1);即复制构造函数
cout<<demo2.i<<endl;
return 0;
}
注意,如果我们把上面程序中的Demo demo2 = demo1分成两句来写,即:
Demo demo2;
demo2 = demo1;
则会发现调用了调用了 operator = (demo1),也就是demo2.operator = (demo1);
假设我们想给demo2赋一个其它类型的值呢?比如,整型int等
我们修改程序如下:
class Demo
{
public:
Demo()
{}
Demo(int j)
{
cout<<"Demo int: "<<j<<endl;
this->i = j;
}
Demo(const Demo& d)
{
cout<<"复制构造函数"<<endl;
}
Demo& operator = (const Demo& d)
{
cout<<"operator ="<<endl;
this->i = d.i;
return *this;
}
Demo& operator = (const int x)
{
this->i = x;
cout<<"operator = int: "<<x<<endl;
return *this;
}
int i;
};
int main()
{
Demo demo2 = 3; //同样,这里等效于Demo demo2 = Demo(3),也就是带一个整型参数的构造函数,另外说明的是,如果要阻止这种隐式转换,可以在Demo(int j)构造方法前加上explicit关键字,这时候就只能显式调用Demo(3)才有效了。即写成:Demo demo2 = Demo(3);
cout<<demo2.i<<endl; //输出3
return 0;
}
同样,如果我们把Demo demo2 = 3;分成两句来写,即:
Demo demo2;
demo2 = 3;
则会发现调用了调用了 operator = (3),也就是demo2.operator = (3);
当然,下面给出一种比较复杂点的上述实现:(只为说明,实际很少用)
class Demo
{
public:
Demo()
{}
explicit Demo(int j)
{
cout<<"Demo int: "<<j<<endl;
this->i = j;
}
Demo(const Demo& d)
{
cout<<"复制构造函数"<<endl;
}
Demo& operator = (const Demo& d)
{
cout<<"operator ="<<endl;
this->i = d.i;
return *this;
}
Demo& operator = (const int x)
{
//this->i = x;
cout<<"operator = int: "<<x<<endl;
return *(new Demo(x));
}
int i;
};
int main()
{
Demo demo2;
demo2 = 3;
cout<<demo2.i<<endl;
return 0;
}