运算符重载：赋值、类型转换

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
去分清直接初始化和拷贝初始化的区别，就可以更加清晰的了解内部含义了。