一个有趣的程序：C++运算符重载中的“指鹿为马”

这个程序涉及到C++的运算符重载和隐含转换

代码如下

#include<iostream>
    using namespace std;

    class Horse
    {
    public:
        Horse(double weight = 0, double speed = 0);
        void speak()const;
    private:
        double weight,speed;
    };

    Horse::Horse(double weight,double speed)
    {
        this->weight = weight;
        this->speed = speed;
    }

    void Horse::speak()const
    {
        cout<<"吾本千里马也！"<<"体重："<<weight<<ends<<"奔跑时速："<<speed<<endl;
    }

    class Deer
    {
    public:
        Deer(double weight = 0,double speed = 0);
        void speak();
        operator Horse()const;
        operator int();
    private:
        double weight,speed;
    };

    Deer::Deer(double weight,double speed)
    {
        this->weight = weight;
        this->speed = speed;
    }

    void Deer::speak()
    {
        cout<<"我是如假包换的鹿"<<endl;
    }

    Deer::operator Horse()const
    {
        return Horse(weight,speed);
    }

    Deer::operator int()
    {
        return weight + speed;
    }

    void listen(const Horse &h)
    {
        h.speak();
    }

    int main()
    {
        Deer d(40,60); //这是一头鹿，
        d.speak(); //我是如假包换的鹿

        listen(d); //指鹿为马，听到鹿说的却是：
                   //吾本千里马也！体重：40kg,奔跑时速：60km/h

        // 更糟糕的是，一头鹿还可以变成int
        int n = d+10; //40+60+10 = 110
        cout<<n<<endl;

        return 0;
    }

operator Horse()和operator int()都为类Deer的成员函数，对强制转换运算符（Horse类的强制转换和int类型的强制转换）进行了重载。

使Deer类的对象能够被强制转化为Horse对象和int类型。

两个隐含转换：

1.在函数void listen()中将传进去的Deer对象隐含的转化为Horse对象，调用了Horse对象的speak()函数，所以听到的是马说的话。

2.n = d+10;这一句将Deer的对象d隐含转化为int类型并参与运算。

测试：

1.显式调用重载函数，在main函数里面加上如下语句，输出结果注释在后面

d.operator Horse().speak(); //吾本千里马也！体重：40kg,奔跑时速：60km/h

d.operator int();//输出100

cout<<d<<endl;

说明：

1.转换运算符的重载方式比较特别，方法如下：

operator 类名();

转换运算符的重载函数是没有返回类型的，它和类的构造函数，析构函数一样是不遵循函数有返回类型的规定的，他们都没有返回值。

2.定义转换函数时应注意如下几点：

(1)转换函数是用户定义的成员函数，但它要是非静态的。

(2)转换函数的不可以有返回值。（意思是声明中不可以有返回值）

(3)转换函数也不带任何参数。

(4)转换函数函数还不能定义为友元函数。

转换函数的名称是类型转换的目标类型，因此，不必再为它指定返回值类型；转换函数是被用于本类型的数值或变量转换为其他的类型，也不必带参数。

类中的构造函数完成其他类型到类类型的转换，而重载强制转换完成类类型到其他类型的转换。