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

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