C++：运算符重载

前言

  重载我们又称之为多态，重载在编程中的用法非常之多，比如最熟悉的函数重载（基于C++开发的capl语言同样支持函数重载）。当然在C++中仍然支持将多态引用到运算符中，例如 * 运算符可以用于地址，也可以用来两数相乘。本质上，C++运算符的重载由操作数类型决定，这类似于函数重载是由形参列表决定。但需要注意的是运算符重载只支持类定义或者结构定义。

	/* *运算符重载 */
	int b = 10;
	int a = 10;
	int* p = &a;// *作用于地址
	int out = *p * b;// *用来相乘
	cout << out << endl;

自定义运算符重载

  运算符重载小白本人（下文及后续其他文章自称本白）认为是一个非常强大好用得功能，其定义方式为 结构名 operateor  运算符  (参数列表) 就拿C++ plus书的例子来说，如果我们定义了A,B,C三个类，并且三个类成员都在public声明了一个整形变量DD，那借用重载+号运算符我们可以直接：

	C=A+B //重载的本质：C.DD=A.DD+B.DD

  可能这样大家看起来还不是很清晰，那借用一个例子我们来完整的看运算符重载到底是怎末实现的：

//头文件
        #pragma once
        #include <iostream>
 
        using namespace std;
 
        class Time
        {
        private:
            int hours;
            int min;
        public:
            Time();
            Time(int h, int m = 0);
            ~Time();
            void Add_min(int m);//增加分钟
            void Add_Hou(int h);//增加小时
            void Reset(int h=0,int m=0) ;//重置类的参数
            Time Sum(const Time& t) const;//两个类的时间相加赋值给第三个类，注意返回值不要引用，因为函数执行完毕后会清除创建的Sum类对象
            void Show() const;//展示成员值
        };

警告：不要返回指向局部变量的引用。函数执行完毕后，局部变量和临时对象将消失（static除外），引用将指向不存在的数据！

        //类成员函数定义CPP文件
        #include "运算符重载.h"
 
        Time::Time()
        {
            hours = min = 0;
        }
 
        Time::Time(int h, int m)
        {
            hours = h;
            min = m;
        }
 
        Time::~Time()
        {
 
        }
 
        void Time::Add_min(int m) //增加分钟
        {
            int h_add=0;
            h_add = (m + min) / 60;
            hours += h_add;
            min = (m + min) % 60;
        }
 
        void Time::Add_Hou(int h) //增加小时
        {
            hours += h;
            if (hours > 24)
            {
                cout << "ERROR HOURS! PLEASE INPUT AGAIN!" << endl;
                hours -= h;
            }
        }
        void Time::Reset(int h, int m) //重置类的参数
        {
            min = m;
            hours = h;
        }
 
        Time Time::Sum(const Time& t) const//两个类的时间相加赋值给第三个类并返回
        {
            Time sum;
            sum.min = (this->min + t.min);
            sum.hours = this->hours + t.hours + sum.min/60;
            sum.min = sum.min % 60;
            return sum;
        }
 
        void Time::Show() const//展示成员值
        {
            cout << "hours#: " << this->hours << endl;
            cout << "minutes#: " << this->min << endl;
        }

        //Main函数文件
        #include <iostream>
        #include "运算符重载.h"
 
        using namespace std;
 
        int main(void)
        {
            Time timeSum;//用于存放总和
            Time time2(10,23);
            Time time3(5,40);
            //没有运算符重载的时候
            cout << "没有运算符重载" << endl;
            timeSum = time2.Sum(time3);
            timeSum.Show();
            return 0;
        }

   运行结果如下：

  可以看出不借助运算符重载我们必须自己顶一个Sum函数来进行两个类成员的变量相加，但是当调用时就显得有点臃肿，如果我们使用 + 运算符重载呢？

    只要在类声明时声明一个运算符重载，并且定义好其重载的具体对象：

        Time Time::operator+(const Time& t) const//定义一个+运算符重载
        {
            Time sum;
            sum.min = (this->min + t.min);
            sum.hours = this->hours + t.hours + sum.min / 60;
            sum.min = sum.min % 60;
            return sum;
        }

  然后运行main函数：

        #include <iostream>
        #include "运算符重载.h"
 
        using namespace std;
 
        int main(void)
        {
            Time timeSum;//用于存放总和
            Time time2(10,23);
            Time time3(5,40);
            //没有运算符重载的时候
            cout << "没有运算符重载" << endl;
            timeSum = time2.Sum(time3);
            timeSum.Show();
 
            //运算符重载
            cout << "运算符重载" << endl;
            timeSum = time3 + time2;
            timeSum.Show();
 
            return 0;
        }

  运行结果如下：

结论  

  其实不难发现，这里的+其实对于类来说就是一个成员函数，只不过+号只是简写罢了：

        timeSum = time3.operator+(time2);

   这也就说明了运算符重载必须是类或者结构，因为operator本质就是一个函数，因此不接受基本变量进行重载！