【C++学习笔记】运算符重载

Myth丶恋晨 2022-10-13 02:58 210阅读 0赞

### 文章目录 ###

*  0x00 前言
 *  0x01 运算符重载
 *  0x02 运算符重载规则
 *  0x03 运算符重载为成员函数
 *  0x04 运算符重载为非成员函数

# 0x00 前言 #

文章中的文字可能存在语法错误以及标点错误，请谅解；

如果在文章中发现代码错误或其它问题请告知，感谢！

本文档为个人边学习边记录的C++笔记，非教程，笔记中会存在引用他人文章内容的部分，被引用的原文不会被特殊标记出来，但会在参考文档中给出原文链接。

# 0x01 运算符重载 #

**运算符重载是对已有的运算符赋予多重含义，使同一运算符作用于不同类型数据时导致不同行为。**

运算符重载的实质就是函数重载。在实现过程中，首先把指定的运算表达式转化为对运算符函数的调用，将运算对象转化为运算符函数的实参，然后根据实参的类型来确定需要调用的函数，这个过程是在编译过程中完成的。

# 0x02 运算符重载规则 #

运算符重载规则如下：  
（1）C++中的运算符处理少数几个之外，全部都可以重载，而且只能重载C++已经有的运算符。  
（2）重载之后的运算符的优先级和结合性都不会改变。  
（3）运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来讲，重载的功能应当与原有功能相似，不能改变元运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。

运算符的重载形式有两种，即**重载为类的非静态成员函数**和**重载为非成员函数**。

运算符重载为类的成员函数一般的语法形式为：

返回类型 operator 运算符(形参表)
    { 
    	函数体
    }

运算符重载为类的非成员函数一般的语法形式为：

返回类型 operator 运算符(形参表)
    { 
    	函数体
    }

**返回类型**指定了重载运算符的返回值类型，也就是运算结果类型；**operator**是定义运算符重载函数的关键字；**运算符**即是要重载的运算符名称，必须是C++中科重载运算符，比如要重载加法运算符，这里就写“+”；**形参表**中给出重在运算符所需要的参数和类型。

当以非成员函数形式重载运算符时，有时需要访问运算符参数所涉及类的私有成员，这时可以把该函数声明为类的友元函数。

当运算符重载为类的成员函数时，函数的参数个数比原来的操作数个数要少一个（后置“++”，“–”除外）；当重载函数为非成员函数时，参数个数与原操作数个数相同。两种情况的参数个数有所差异的原因是，重载为类的成员函数时，第一个操作数会被作为函数调用的目的对象，因此无需出现在参数表中，函数体中可以直接访问第一个操作数的成员；而重载为非成员函数时，运算符的所有操作数必须显式通过参数传递。

**运算符重载的主要优点就是可以改变现有运算符的操作方式，以用于类类型，使得程序看起来更加直观。**

# 0x03 运算符重载为成员函数 #

运算符重载实质上就是函数重载，重载为成员函数，它就可以自由的访问本类数据成员。

**如果是双目运算符，左操作数就是对象本身的数据，由this指针指出，右操作数则需要通过运算符重载函数的参数表来传递；如果是单目运算符，操作数由对象的this指针给出，就不再需要任何参数。**

对于**双目运算符**B，如果要重载为类的成员函数，使之能够实现表达式oprd1 B oprd2，其中oprd1为A类的对象，则应当把B重载为A类的成员函数，该函数只有一个形参，形参的类型是oprd2所属的类型。经过重载之后，表达式oprd1 B oprd2就相当于函数调用oprd1.operatorB（oprd2）.

对于**前置单目运算符**U，如“-”（负号）等，如果要重载为类的成员函数，用来实现表达式U oprd，其中oprd为A类的对象，则U应当重载为A类的成员函数，函数没有形参。经过重载之后，表达式U oprd相当于函数调用oped.operator U（）。

**后置运算符**“++”和“–“，如果将它们重载为类的成员函数，用来实现表达式oprd++或oprd–，其中oprd为A类对象，那么运算符就应当重载为A类的成员函数，这时函数要带有一个整型（int）形参。重载之后，表达式oprd++和oprd–就相当于函数调用oprd.operator++(0)和oprd.operator–(0).这里的int类型参数在运算中不起任何作用，只是用于区别后置++、–与前置++、–。

在UML语言中，重载的运算符表示方法与其他成员函数类似，其形式为”operator 运算符（形参表）：函数类型“。

例：复数类加减法运算重载为成员函数成员。  
![在这里插入图片描述][20210706104959656.jpg_pic_center]

带有加减法运算符重载的复数类的UML图形表示

#include<iostream>
    
    using namespace std;
    
    class Complex{ 
        public:
            Complex(double r = 0.0, double i = 0.0):real(r), imag(i){ }
            Complex operator+(const Complex &c2) const;
            Complex operator-(const Complex &c2) const;
            void display() const;
        private:
            double real;
            double imag;
    };
    
    Complex Complex::operator+(const Complex &c2) const{ 
        return Complex(real + c2.real, imag + c2.imag);
    }
    
    Complex Complex::operator-(const Complex &c2) const{ 
        return Complex(real - c2.real, imag - c2.imag);
    }
    
    void Complex::display() const{ 
        cout<<"("<<real<<","<<imag<<")"<<endl;
    }
    
    int main(){ 
        Complex c1(5, 4), c2(2, 10), c3;
        cout<<"c1 = ";c1.display();
        cout<<"c2 = ";c2.display();
        c3 = c1 - c2;
        cout<<"c3 = c1 - c2 = ";c3.display();
        c3 = c1 + c2;
        cout<<"c3 = c1 + c2 = ";c3.display();
    
        return 0;
    }

运行结果：

c1 = (5,4)
    c2 = (2,10)
    c3 = c1 - c2 = (3,-6)
    c3 = c1 + c2 = (7,14)

例：将单目运算符“++”重载为成员函数形式

#include<iostream>
    using namespace std;
    class Clock{ 	
    public:
    	Clock(int hour = 0, int minute = 0, int second = 0);
    	void showTime() const;
    	Clock & operator++();	//前置单目运算符重载
    	Clock operator++(int);	//后置单目运算符重载
    private:
    	int hour, minute, second;
    };
    
    Clock::Clock(int hour, int minute, int second){ 
    	if(0 <= hour && hour < 24 && 0 <= minute && minute < 60 
    		&& 0 <= second && second < 60){ 
    		this->hour = hour;
    		this->minute = minute;
    		this->second = second;
    	}else
    		cout << "Time error!" << endl;
    }
    
    void Clock::showTime() const{ 
    	cout << hour << ":" << minute << ":" << second << endl;
    }
    
    Clock &Clock::operator++(){ 	//前置单目运算符重载函数
    	second++;
    	if(second >= 60){ 
    		second -= 60;
    		minute++;
    		if(minute >= 60){ 
    			minute -= 60;
    			hour = (hour + 1) % 24;
    		}
    	}
    	return *this;
    }
    
    Clock Clock::operator++(int){ 	//后置单目运算符重载函数
    	Clock old = *this;
    	++(*this);
    	return old;
    }
    
    int main(){ 
    	Clock myClock(23, 59, 59);
    	cout << "First time output" << endl;
    	myClock.showTime();
    	cout << "Show myClock++:";
    	(myClock++).showTime();
    	cout << "Show++myClock:";
    	(++myClock).showTime();
    	
    	return 0;
    }

运行结果：

First time output
    23:59:59
    Show myClock++:23:59:59
    Show++myClock:0:0:1

前置单目运算符和后置单目运算符的重载最主要的区别在于重载函数的形参。语法规定，前置单目运算符重载为成员函数时没有形参，而后置单目运算符重载为成员函数时需要有一个int型形参。

# 0x04 运算符重载为非成员函数 #

运算符也可以重载为非成员函数。这时，运算所需要的操作数都需要通过函数的形参表来传递，在形参表从左到右的顺序就是运算符操作数的顺序。如果需要访问运算符参数对象的私有成员，可以将该函数声明为类的友元类。

对于双目运算符B，如果要实现oprd1 B oprd2，其中oprd1和oprd2中只要有一个具有自定义类型，就可以将B重载为非成员函数，函数的形参为oprd1和oprd2.经过重载之后，表达式oprd1 B oprd2就相当于函数调用operator B（oprd1， oprd2）。

对于前置单目运算符U，如“-”（负号）等，如果要实现表达式U oprd，其中oprd具有自定义类型，就可以将U重载为非成员函数，函数的形参为oprd。经过重载之后，表达式U oprd相当于函数调用operator U（oprd）。

对于后置运算符++和–，如果要实现表达式oprd++或oprd–，其中oprd为自定义类型，那么运算符就可以重载为非成员函数。这时函数的形参有两个，一个oprd，另一个时int类型形参。第二个参数是用于与前置运算符函数相区别的。重载之后，表达式oprd++和oprd–就相当于函数调用operator++（oprd，0）和operator–（oprd，0）。

例：以非成员函数形式重载Complex的加减运算和“<<”运算符。  
![在这里插入图片描述][20210706143219315.jpg_pic_center]

加减法运算符和“<<”重载为非成员函数形式复数类的UML图形表示

#include<iostream>
    using namespace std;
    
    class Complex{ 
        public:
            Complex(double r = 0.0, double i = 0.0):real(r), imag(i){ }
            friend Complex operator+(const Complex &c1, const Complex &c2);
            friend Complex operator-(const Complex &c1, const Complex &c2);
            friend ostream & operator << (ostream &out, const Complex &c);
        private:
            double real;
            double imag;
    };
    
    Complex operator+(const Complex &c1, const Complex &c2){ 
        return Complex(c1.real + c2.real, c1.imag + c2.imag);
    }
    
    Complex operator-(const Complex &c1, const Complex &c2){ 
        return Complex(c1.real - c2.real, c1.imag - c2.imag);
    }
    
    ostream & operator<<(ostream &out, const Complex &c){ 
    	out << "(" << c.real << "," << c.imag << ")";
    	return out;
    }
    
    int main(){ 
        Complex c1(5, 4), c2(2, 10), c3;
        cout<<"c1 = "<< c1 << endl;
        cout<<"c2 = "<< c2 << endl;
        c3 = c1 - c2;
        cout<<"c3 = c1 - c2 = "<< c3 << endl;
        c3 = c1 + c2;
        cout<<"c3 = c1 + c2 = " << c3 << endl;
    
        return 0;
    }

运行结果：

c1 = (5,4)
    c2 = (2,10)
    c3 = c1 - c2 = (3,-6)
    c3 = c1 + c2 = (7,14)

将运算符重载为类的非成员函数，就必须把操作数通过形参的方式传递给运算符重载函数。“<<”操作符的左操作数为ostream类型的引用，ostream是cout类型的一个基类，右操作数是Complex类型的引用，这样在执行cout<<c1时，就会调用operator<<(cout, c1)。该函数把通过第一个参数传入的ostream对象以引用形式返回，这是为了支持形如“cout << c1 <<c2”的连续输出，因为第二个"<<“运算符的左操作数是第一个”<<"运算符的返回结果。和上例相比，主函数中的“+”，“-”的用法没有改动，而对Complex对象的输出更加直观了，程序运行的结果完全相同。

《C++语言程序设计（第4版）》书上所有章节出现的示例源代码随着学习的深入会陆续上传至github，代码为个人手动输入并通过编译，有的示例代码可能没有注释：[https://github.com/fyw4/C-plus-plus-learning-example][https_github.com_fyw4_C-plus-plus-learning-example]

以上。

参考文档：  
郑莉 董渊 何江舟.《C++语言程序设计（第4版）》\[M\].北京：清华大学出版社。

[20210706104959656.jpg_pic_center]: /images/20221005/dc2e5518e5934f3397a591be35feb9f5.png
[20210706143219315.jpg_pic_center]: /images/20221005/ad9f9ae6d2cc4159a0e2e8af494a66ed.png
[https_github.com_fyw4_C-plus-plus-learning-example]: https://github.com/fyw4/C-plus-plus-learning-example