服务器之家：专注于VPS、云服务器配置技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - C/C++ - C语言运算符的重载详细介绍

C语言运算符的重载详细介绍

2022-09-29 16:34PingBryant C/C++

这篇文章主要为大家详细介绍C语言运算符的重载，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助

运算符重载的规则 

  • 思考：用“+”、“-”能够实现复数的加减运算吗？
  • 实现复数加减运算的方法：

             ——重载“+”、“-”运算符

  • 运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为。
  • C++ 几乎可以重载全部的运算符，而且只能够重载C++中已经有的。

                不能重载的运算符：“.”、“.*”、“::”、“?:”

  • 重载之后运算符的优先级和结合性都不会改变。
  • 运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。例如：                 

                使复数类的对象可以用“+”运算符实现加法；

                使时钟类对象可以用“++”运算符实现时间增加1秒。

  • 重载为类的非静态成员函数；
  • 重载为非成员函数。 

1. 运算符重载为成员函数

重载为类成员的运算符函数定义形式：

函数类型 operator 运算符（形参）

{

......

}

参数个数=原操作数个数-1 （后置++、--除外） 

双目运算符重载规则

  • 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
  • 经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2) 。 

例1 复数类加减法运算重载为成员函数

要求：将+、-运算重载为复数类的成员函数。

规则：实部和虚部分别相加减。

操作数：两个操作数都是复数类的对象。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include<iostream>
using namespace std;
//定义复数类
class Complex
{
    public:
        Complex(double x=0.0, double y=0.0);  //构造函数
        Complex(const Complex &c);  //复制构造函数
        ~Complex();  //析构函数
        void display() const;  //复数打印函数
        Complex operator +(const Complex &c) const;  //加法运算符重载
        Complex operator -(const Complex &c) const;  //减法运算符重载
    private:
        double real;  //实部
        double imag;  //虚部
};
Complex::Complex(double x, double y): real(x), imag(y){}
Complex::~Complex(){}
Complex::Complex(const Complex &c): real(c.real), imag(c.imag){}
void Complex::display() const
{
    cout<<"("<<real<<", "<<imag<<")"<<endl;
}
Complex Complex::operator +(const Complex &c) const
{
    Complex temp;
    temp.real = real + c.real;
    temp.imag = imag + c.imag;
    return temp;
    /*或者创建一个临时无名对象作为返回值*/
    //return Complex(real+c.real, imag+c.imag);
}
Complex Complex::operator -(const Complex &c) const
{
    Complex temp;
    temp.real = real - c.real;
    temp.imag = imag - c.imag;
    return temp;
}
int main()
{
    Complex c1(6.7, 4.4);
    Complex c2(3.2, 1.7);
    cout<<"c1 = ";
    c1.display();
    cout<<endl;
    cout<<"c2 = ";
    c2.display();
    cout<<endl;
    Complex c3, c4;
    c3 = c1 + c2;
    c4 = c1 - c2;
    cout<<"c1 + c2 = ";
    c3.display();
    cout<<endl;
    cout<<"c1 - c2 = ";
    c4.display();
    cout<<endl;
    return 0;
}

运行结果：

c1 = (6.7, 4.4)
c2 = (3.2, 1.7)
c1 + c2 = (9.9, 6.1)
c1 - c2 = (3.5, 2.7)

前置单目运算符++和--重载规则 

  • 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为A类对象，则 U 应被重载为 A 类的成员函数，无形参。
  • 经重载后，表达式 U oprd 相当于 oprd.operator U()。 

后置单目运算符++和--重载规则

  • 如果要重载 ++或--为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ，其中 oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。
  • 经重载后，表达式 oprd++ 相当于 oprd.operator ++(0)。 

例2 重载前置++和后置++为时钟类成员函数

前置单目运算符，重载函数没有形参。         

后置++运算符，重载函数需要有一个int形参。         

操作数是时钟类的对象。         

实现时间增加1秒钟。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include<iostream>
using namespace std;
class Clock
{
    public:
        Clock(int hour=0, int minute=0, int second=0);
        ~Clock();
        void showTime() const;
        Clock& operator ++();  //前置单目运算符重载
        Clock operator ++(int);  //后置单目运算符重载
    private:
        int hour;
        int minute;
        int 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;
    }
}
Clock::~Clock(){}
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);   //调用前置“++”运算符
    /*也可以写具体：
    second++;
    if(second >= 60)
    {
        second %= 60;
        minute++;
        if(minute >= 60)
        {
            minuet %= 60;
            hour = (hour + 1) % 24;
        }
    }
    */
    return old;
}
int main()
{
    Clock myClock(23, 59, 59);
    cout << "First time output: ";
    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

2. 运算符重载为非成员函数          

有些运算符不能重载为成员函数，例如二元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象。 

运算符重载为非成员函数的规则 

  • 函数的形参代表依自左至右次序排列的各操作数。
  • 重载为非成员函数时：

                参数个数=原操作数个数（后置++、--除外）。

  • 至少应该有一个自定义类型的参数。
  • 后置单目运算符++和--的重载函数，形参列表中要增加一个int，但不必写形参名。
  • 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元。
  • 双目运算符B重载后， 表达式oprd1 B oprd2等同于operator B(oprd1,oprd2)。
  • 前置单目运算符B重载后，表达式B oprd等同于operator B(oprd)。
  • 后置单目运算符++和--重载后，表达式oprd B等同于operator B(oprd,0)。

例3 重载 Complex 的加减法和“<<”运算符为非成员函数

  • 将+、‐（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用（使用常引用，既保证程序执行的高效率，又保护数据不被随意篡改）。
  • 将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用，用以支持下面形式的输出：        

 cout << a << b;

该输出调用的是：         

operator << (operator << (cout, a), b);

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include<iostream>
using namespace std;
class Complex
{
    public:
        Complex(double x=0.0, double y=0.0);
        ~Complex();
        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::Complex(double x, double y): real(x), imag(y){}
Complex::~Complex(){}
Complex operator +(const Complex &c1, const Complex &c2)
{
    Complex temp;
    temp.real = c1.real + c2.real;
    temp.imag = c1.imag + c2.imag;
    return temp;
    /*或者创建一个临时无名对象作为返回值*/
    //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;
}
/*若输出为复数的标准形式：
在复数两端加上括号，实部和虚部均保留两位小数，
如(8.23+2.00i)、(7.45-3.40i)*/
/*
ostream& operator <<(ostream& out, const Complex &c)
{
    if(c.imag>0)
        out<<setiosflags(ios::fixed)<<setprecision(2)<<"("<<c.real<<"+"<<c.imag<<"i)"<<endl;
    else
        out<<setiosflags(ios::fixed)<<setprecision(2)<<"("<<c.real<<c.imag<<"i)"<<endl;
    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)

类的友元函数重载插入运算符和重载提取运算符在调用时只需像平常cin >> xxx 或 cout << xxx即可，而类的成员函数重载插入运算符和重载提取运算符在调用时是要xxx >> cin 或 xxx << cout，刚好和平常的用法是相反的。而xxx >> cin相当于xxx.operator>>(cin)；xxx << cout相当于xxx.operator<<(cout)。

用引用&，减少对象拷贝，增加速度和效率。插入和提取运算符，操作的对象是ostream和istream。如果不加&的话，程序也是没问题的，可以运行。但是在每次调用<<操作的时候，都会产生一个新的临时的ostream对象。包括对“=”运算符的重载也是一样。“=”更能说明这个问题。一般来说是 xxx & opreator = (xxx a);就是因为我们希望对于a=b; 把b的值直接赋值给a就好了，用xxx &做返回类型，返回的是a的别名/引用，不会创建新的临时对象。如果没有&，那么会创建新的临时值返回，低效。重点就是对引用&的使用的理解。

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容! 

原文链接：https://blog.csdn.net/PingBryant/article/details/123089725

  • C语言
  • 运算符
  • 重载

    • 延伸 · 阅读

    精彩推荐
    • C/C++C++合并二叉树的思路与示例代码

      C++合并二叉树的思路与示例代码

      二叉树大家应该都不陌生,但是合并二叉树呢?这篇文章主要给大家介绍了关于C++合并二叉树的相关资料,文中给出了两种解决的方法,大家可以根据需要选择对...

      久病成良医5002021-12-13
    • C/C++C++破坏MBR的代码

      C++破坏MBR的代码

      这篇文章主要介绍了C++破坏MBR的代码,涉及到对硬盘的主引导记录的破坏性操作,具有一定的参考价值,需要的朋友可以参考下...

      C++教程网6912021-02-06
    • C/C++学习C++指针声明和指针相关概念

      学习C++指针声明和指针相关概念

      C++ 指针学习起来有点难，但是很重要。一些 C++ 程序使用指针更容易执行，另外其他 C++ 程序，例如动态内存分配，没有指针就无法执行。...

      Python之王7412021-06-11
    • C/C++C++ 容器适配器priority_queue的使用及实现代码

      C++ 容器适配器priority_queue的使用及实现代码

      这篇文章主要介绍了C++ 容器适配器priority_queue的使用及实现,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要...

      WhiteShirtI7122021-11-02
    • C/C++C语言宏定义#define的使用

      C语言宏定义#define的使用

      本文主要介绍了C语言宏定义#define的使用，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下...

      南城Flipped6532022-08-14
    • C/C++C++ 程序抛出异常后执行顺序说明

      C++ 程序抛出异常后执行顺序说明

      这篇文章主要介绍了C++ 程序抛出异常后执行顺序说明，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      无鞋童鞋11782021-10-25
    • C/C++vs code 配置python虚拟环境的方法

      vs code 配置python虚拟环境的方法

      这篇文章主要介绍了vs code 配置python虚拟环境的方法，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下...

      SpuerCheng8482021-08-27
    • C/C++C语言入门篇--变量[定义,初始化赋值,外部声明]

      C语言入门篇--变量[定义,初始化赋值,外部声明]

      本篇文章是c语言基础篇，本文对初识c语言的变量、变量的定义、初始化与赋值、变量的分类、含义、外部声明做了简要的描述，帮助大家快速入门c语言的...

      yycure6352021-12-22
    最近更新
    编辑推荐
    阅读排行
    热门标签
    1015 　 裂缝 　 地址参数 　 多继承法 　 ZOJ 　 Fishing 　 同名 　 libfreetype 　 Simulink 　 数据滚动 　 右值引用 　 NSString 　 消息传递 　 平滑处理 　 Visual C++ 　 栈区 　 堆区 　 C语言程序设计 　 内存错误 　 对象模型 　 颜色加亮 　 程序内部 　 strcat 　 WinExec 　 打开程序 　 错误调试 　 C++教程 　 tinyxml 　 XML解析器 　 静态存储区 　
    © 2019-2022 服务器之家(www.tuohang.net) 版权所有关于我们联系我们版权申明网站地图