1、区分初始化,赋值
赋值运算符重载的原型为:
class T{
T& operator=(const T& rhs);
//注意:此处一定要返回对象的引用,否则返回后其值立即消失,即调用拷贝构造函数return一个临时变量。
}
T& T::operator=(const T& rhs){
//check for self assignment
if(this != &rhs){
//perform assignment
}
return *this;
}
在C++中,如果类中有动态分配内存的,那么需要重载赋值运算符。如果没有动态分配内存,那么可以用缺省的赋值运算符。如下代码则需要重载赋值运算符:
class A{
public:
A(){}
private:
char *p;
};
int main()
{
A a,b;
a=b;
return 0;
}
下面代码区分赋值和初始化
#include <iostream>
using namespace std;
class Fi
{
public:
Fi() {cout<<"Fi()"<<endl;}//1构造函数
Fi(const Fi& i){cout<<"Fi(const Fi& i)"<<endl;}
~Fi(){cout<<"~Fi()"<<endl;
}
};
class Fee
{
public:
Fee(int) {cout<<"Fee(int)"<<endl;}//2构造函数
Fee(const Fee& ee){cout<<"Fee(const Fee& ee)"<<endl;}
Fee& operator=(const Fee& o){
cout<<"=="<<endl;
}
Fee(const Fi&) {cout<<"Fee(const Fi&)"<<endl;}//3构造函数
~Fee(){cout<<"~Fee()"<<endl;}
};
int main()
{
Fee fee = 1;//2构造函数
Fi fi;//1构造函数
Fee fum = fi;//3构造函数
fum = fi;//3构造函数并赋值(赋值运算符重载,如果类中没有定义,则调用系统默认的赋值运算符)
return 0;
};
2、C++提供了关键字explicit,可以阻止不被允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。
#include <iostream>
using namespace std;
class One
{
public:
One() {}
};
class Two
{
public:
explicit Two(const One&) {}
};
void f(Two) {}
int main()
{
One one;
//f(one);//error C2664: “void f(Two)”: 无法将参数 1 从“One”转换为“Two”
f(Two(one));//构造一个类Two
return 0;
};
3、类型转换的方式可以有以下两种:
将定义的T类型转换成C类
- 1、 -if C(T) is a valid constructor call for C
class C{
public:
C(T); //C(const C& T)..etc
};
- 2、 -if operator C() is defined for T
class T{
public:
operator C()const;
};
比如将Apple类型变成Orange类型:
class Orange(); //前项声明
class Apple{
public:
operator Orange()const;
};
class Orange{
public:
Orange(Apple);
};
void f(Orange){}
int main()
{
Apple a;
f(a); //error: ambiguous conversion
return 0;
}
虽然两种方法都可以实现类型转换,但是如果两种都写,那么就会发生二义性。
当然,如果还有一些疑问,推荐阅读:
http://blog.csdn.net/ljianhui/article/details/9245661
http://www.cnblogs.com/cposture/p/4925736.html
去分清直接初始化和拷贝初始化的区别,就可以更加清晰的了解内部含义了。