十个 C++ 运算符重载示例，看完不懂打我...

最新推荐文章于 2024-10-29 14:35:26 发布
最新推荐文章于 2024-10-29 14:35:26 发布
阅读量3.9w 收藏 1.3k
点赞数 222
分类专栏： C++从入门到出门 文章标签： C++ 物联网 编程语言
未经授权许可，禁止以任何形式转载！
本文链接：https://blog.csdn.net/lu_embedded/article/details/121599696
版权

下面是一些 C++ 运算符重载示例，包括算术运算符、赋值运算符、逻辑运算符、成员运算符、关系运算符等等，这些都是使用频率较高的几个运算符重载案例。

⭐️ 所有示例代码均存放于 GitHub: getiot/cpp-courses/operator_overloading 。

示例 1：一元运算符重载

一元运算符即只对一个操作数进行操作的运算符，例如：!obj、-obj、++obj 、obj++ 或 obj-- 等等。

下面示例将对负号（-）进行重载：

#include <iostream>
using namespace std;

class Distance
{
private:
    int feet;    // 0 到无穷
    int inches;  // 0 到 12
public:
    // 构造函数
    Distance() {
        feet = 0;
        inches = 0;
    }
    Distance(int f, int i) {
        feet = f;
        inches = i;
    }
    
    // 显示距离
    void displayDistance() {
        cout << "F: " << feet << ", I: " << inches << endl;
    }
    
    // 重载负运算符 ( - )
    Distance operator- () {
        feet = -feet;
        inches = -inches;
        return Distance(feet, inches);
    }
};

int main(void)
{
    Distance d1(1, 10), d2(-5, 110);
    
    -d1;                     // 取相反数
    d1.displayDistance();    // 距离 D1
    
    -d2;                     // 取相反数
    d2.displayDistance();    // 距离 D2
    
    return 0;
}

编译并运行以上示例，输出结果如下：

F: -1, I: -10
F: 5, I: -110

示例 2：二元运算符重载

二元运算符即需要两个参数的运算符，例如：加运算符（+）、减运算符（-）、乘运算符（*）、除运算符（/）。

下面示例将重载加运算符（+）：

#include <iostream>
using namespace std;

class Box
{
    double length;  // 长度
    double width;   // 宽度
    double height;  // 高度

public:
    Box () {
        length = 0.0;
        width  = 0.0;
        height = 0.0;
    }

    Box (double a, double b ,double c)
    {
        length = a;
        width  = b;
        height = c;        
    }

    double getVolume(void)
    {
        return length * width * height;
    }

    // 重载 + 运算符，用于把两个 Box 对象相加
    Box operator+(const Box& b)
    {
        Box box;
        box.length = this->length + b.length;
        box.width  = this->width + b.width;
        box.height = this->height + b.height;
        return box;
    }
};

int main(void)
{
    Box b1(5.0, 4.0, 3.0);
    Box b2(6.0, 5.0, 4.0);
    Box b3;

    cout << "Volume of b1 : " << b1.getVolume() << endl;
    cout << "Volume of b2 : " << b2.getVolume() << endl;

    // 把两个对象相加，得到 Box3
    b3 = b1 + b2;

    // Box3 的体积
    cout << "Volume of b3 : " << b3.getVolume() << endl;

    return 0;
}

使用 g++ main.cpp && ./a.out 命令编译运行以上示例，输出结果如下：

Volume of b1 : 60
Volume of b2 : 120
Volume of b3 : 693

示例 3：关系运算符重载

C++ 允许重载任何一个关系运算符（例如 < 、 > 、 <= 、 >= 、 == 等），重载后的关系运算符可用于比较类的对象。许多 C++ 内置的数据类型也都支持各种关系运算符。

下面示例将重载小于符（<）：

#include <iostream>
using namespace std;

class Rect
{
private:
    double width;
    double height;

public:
    Rect(double a, double b)
    {
        width  = a;
        height = b;
    }

    double area() {
        return width * height;
    }

    // 重载小于运算符 ( < ), 按照面积比大小
    bool operator<(Rect& that)
    {
        return this->area() < that.area();
    }
};

int main()
{
    Rect r1(3.0, 5.0), r2(3.5, 4.5);

    cout << "Area of r1 = " << r1.area() << endl;
    cout << "Area of r2 = " << r2.area() << endl;

    if ( r1 < r2 )
        cout << "r1 is less than r2" << endl;
    else
        cout << "r1 is large than r2" << endl;

   return 0;
}

编译运行以上代码，输出结果如下：

Area of r1 = 15
Area of r2 = 15.75
r1 is less than r2

示例 4：输入/输出运算符重载

C++ 使用流提取运算符（>>）和流插入运算符（<<）来输入和输出内置的数据类型，同时也允许重载 >> 和 << 来操作对象等用户自定义的数据类型。

可以把运算符重载函数声明为类的友元函数，这样就可以不用创建对象而直接调用函数。

#include <iostream>
using namespace std;

class Rect
{
public:
    double width;
    double height;

    Rect() {
        width = 0;
        height = 0;
    }

    Rect(double a, double b )
    {
        width  = a;
        height = b;
    }

    double area() {
        return width * height;
    }

    friend std::ostream &operator<<(std::ostream &output, Rect &r)
    { 
        output << "width: " << r.width << ", ";
        output << "height: " << r.height << ", ";
        output << "area: " << r.area();

        return output;
    }

    friend std::istream &operator>>(std::istream &input, Rect &r)
    {
        input >> r.width >> r.height;
        return input;            
    }
};

int main()
{
    Rect r1(3.0, 4.0), r2(6.0, 8.0), r3;
    
    cout << "Enter the value of object: \n";
    cin >> r3;
    cout << "r1: " << r1 << endl;
    cout << "r2: " << r2 << endl;
    cout << "r3: " << r3 << endl;
    
    return 0;
}

编译和运行以上示例，输出结果如下：

Enter the value of object: 
2 3
r1: width: 3, height: 4, area: 12
r2: width: 6, height: 8, area: 48
r3: width: 2, height: 3, area: 6

示例 5：++ 和 – 运算符重载

递增运算符（++）和递减运算符（--）是 C++ 语言中两个重要的一元运算符，包括前缀和后缀两种用法。

下面示例将演示如何重载前缀自增（++obj）和后缀自减运算符（obj--）：

#include <iostream>
using namespace std;

class Time
{
private:
    int minute;             
    int second;

public:
    Time () {
        minute = 0;
        second = 0;
    }

    Time (int m, int s) {
        minute = m;
        second = s;
    }

    void display() {
        cout << minute << " : " << second << endl;
    }

    // 重载前缀递增运算符 ( ++ )
    Time operator++() {
        second++;

        if (second >= 60) {
            minute++;
            second = 0;
        }

        return Time(minute, second);
      }
    
    // 重载后缀递增运算符（ ++ ）
    Time operator++(int)
    {
        Time t(minute, second);  // 保存原始值
        second++;                // 对象加 1

        if (second >= 60) {
            minute++;
            second = 0;
        }

        return t;  // 返回旧的原始值
    }
};

int main()
{
    Time t1(12, 58), t2(0,45);
    
    t1.display();
    (++t1).display();
    (++t1).display();
    
    t2.display();
    (t2++).display();
    (t2++).display();
    
    return 0;
}

编译运行以上示例，输出结果如下：

12 : 58
12 : 59
13 : 0
0 : 45
0 : 45
0 : 46

示例 6：赋值运算符重载

C++ 允许重载赋值运算符（=），用于创建一个对象，比如拷贝构造函数。

下面示例重载 Rect 中的赋值运算符，并在每次拷贝的时候就把长度和宽度数值各加 1。

#include <iostream>
using namespace std;

class Rect
{
private:
    double width;
    double height;

public:
    Rect() {
        width = 0;
        height = 0;
    }

    Rect(double a, double b) {
        width = a;
        height = b;
    }

    void display() {
        cout << " width: " << width;
        cout << " height: " << height;
    }

    void operator= (const Rect &r)
    {
        width = r.width + 1;
        height = r.height + 1;
    }
};

int main()
{
    Rect r1(3.0, 4.0), r2;
    
    r2 = r1;

    cout << "r1: ";
    r1.display();
    cout << endl;

    cout << "r2: ";
    r2.display();
    cout << endl;

    return 0;
}

编译和运行以上示例，输出结果如下：

r1:  width: 3 height: 4
r2:  width: 4 height: 5

示例 7：函数调用运算符重载

C++ 允许重载函数调用运算符（即 () 符号）。重载 () 的目的不是为了创造一种新的调用函数的方式，而是创建一个可以传递任意个参数的运算符函数。其实就是创建一个可调用的对象。

下面示例将演示重载函数调用运算符的妙用：

#include <iostream>
using namespace std;

class Rect
{
private:
    int width;
    int height;

public:
    Rect() {
        width  = 0;
        height = 0;
    }

    Rect(int a ,int b) {
        width  = a;
        height = b;
    }

    void operator()() {
        cout << "Area of myself is:" << width * height << endl;
    }
};

int main()
{
    Rect r1(3, 4), r2(6, 8);

    cout << "r1: "; 
    r1();

    cout << "r2: ";
    r2();
    
    return 0;
}

编译和运行以上示例，输出结果如下：

r1: Area of myself is:12
r2: Area of myself is:48

示例 8：下标运算符重载

下标操作符（[]）通常用于访问数组元素。C++ 允许重载下标运算符用于增强操作 C++ 数组的功能，重载下标运算符最重要的作用就是设置一个哨兵，防止数组访问越界。

下面示例演示重载下标运算符：

#include <iostream>
using namespace std;

const int SIZE = 10;

class Fibo
{
private:
    // 偷懒，防止把 SIZE 设置的过小
    int arr[SIZE+3];

public:
    Fibo() {
        arr[0] = 0;
        arr[1] = 1;

        for(int i=2; i<SIZE; i++) {
            arr[i] = arr[i-2] + arr[i-1];
        }
    }

    int& operator[](unsigned int i) {
        if (i >= SIZE) {
            std::cout << "(索引超过最大值) ";
            return arr[0]; // 返回第一个元素
        }
        return arr[i];
    }
};

int main()
{
    Fibo fb;
    
    for (int i=0; i<SIZE+1; i++) {
        cout << fb[i] << " ";
    }
    cout << endl;
    
    return 0;
}

编译和运行以上示例，输出结果如下：

0 1 1 2 3 5 8 13 21 34 (索引超过最大值) 0

示例 9：类成员访问运算符重载

C++ 允许重载类成员访问运算符（->），用于为一个类赋予 “指针” 行为。重载 -> 运算符时需要注意以下几点：

  • 运算符 -> 必须是一个成员函数；
  • 如果使用了 -> 运算符，返回类型必须是指针或者是类的对象；
  • 运算符 -> 通常与指针引用运算符 * 结合使用，用于实现智能指针的功能；
  • 这些指针是行为与正常指针相似的对象，唯一不同的是，通过指针访问对象时，它们会执行其它的任务（比如，当指针销毁时，或者当指针指向另一个对象时，会自动删除对象）。

间接引用运算符 -> 可被定义为一个一元后缀运算符，比如：

class Ptr{
   //...
   X * operator->();
};

类 Ptr 的对象可用于访问类 X 的成员，使用方式与指针的用法十分相似，如下：

void f(Ptr p )
{
    p->m = 10 ; // (p.operator->())->m = 10
}

语句 p->m 被解释为 (p.operator->())->m。通过下面示例加深理解：

#include <iostream>
#include <vector>

using namespace std;

// 假设一个实际的类
class Obj
{
    static int i, j;

public:
    void f() const { cout << i++ << endl; }
    void g() const { cout << j++ << endl; }
};

// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;

// 为上面的类实现一个容器
class ObjContainer
{
    std::vector<Obj*> a;

public:
    void add(Obj* obj) {
        a.push_back(obj);  // 调用向量的标准方法
    }

    friend class SmartPointer;
};

// 实现智能指针，用于访问类 Obj 的成员
class SmartPointer {
    ObjContainer oc;
    int index;

public:
    SmartPointer(ObjContainer& objc)
    {
        oc = objc;
        index = 0;
    }
    // 前缀版本
    // 返回值表示列表结束
    bool operator++() 
    {
        if(index >= oc.a.size())
            return false;
        
        if(oc.a[++index] == 0)
            return false;
        
        return true;
    }
    // 后缀版本
    bool operator++(int)
    {
        return operator++();
    }

    // 重载运算符 ->
    Obj* operator->() const 
    {
        if(!oc.a[index]) {
            std::cout << "Zero value";
            return (Obj*)0;
        }

        return oc.a[index];
    }
};

int main() 
{
    const int sz = 6;

    Obj o[sz];
    ObjContainer oc;

    for(int i=0; i<sz; i++) {
        oc.add(&o[i]);
    }

    SmartPointer sp(oc); 

    do {
        sp->f(); 
        sp->g();
    } while(sp++);

    return 0;
}

编译和运行以上示例，输出结果如下：

10
12
11
13
12
14
13
15
14
16
15
17

示例 10：逻辑非运算符重载

逻辑非（!）运算符是一元运算符，它总是出现在所操作对象的左边，如 !obj。逻辑非运算符运算符返回的类型为 bool 类型，当对象为真值时，返回假；当对象为假值时，返回真。

下面示例演示如何重载 ! 运算符：

#include <iostream>
using namespace std;

class Rect
{
private:
    int width;
    int height;

public:
    Rect() {
        width = 0;
        height = 0;
    }

    Rect( int a, int b ) {
        width = a;
        height = b;
    }

    int area () {
        return width * height;
    }

    // 当 width 或者 height 有一个小于 0 则返回 true
    bool operator!() {
        if ( width <= 0 || height <= 0 ) {
            return true;
        }
        return false;
    }
};

int main()
{
    Rect r1(3, 4), r2(-3, 4);

    if (!r1) cout << "r1 is not a rectangle" << endl;
    else cout << "r1 is a rectangle" << endl;

    if (!r2) cout << "r2 is not a rectangle" << endl;
    else cout << "r2 is a rectangle" << endl;
    
    return 0;
}

使用 g++ main.cpp && ./a.out 命令编译和运行以上示例，输出结果如下：

r1 is a rectangle
r2 is not a rectangle

点击 GetIoT.tech 学习更多 C++ 编程知识！

C++初阶讲解—运算符重载汇总+实例（上）
m0_57781768的博客
11-17 1507
运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
运算符重载示例.rar.rar
05-05
通过这个"运算符重载示例"，我们可以看到如何在实际代码中应用这些概念。它可能包含了类定义、成员函数和友元函数的实现，展示了如何通过重载`+`、`*`等运算符来完成特定的操作，如向量的加法和乘法。这样的示例有助...
C++运算符重载练习一
llkyusuen的博客
04-11 248
定义Point类，有坐标x,y两个成员变量，利用友元函数对Point类重载“++”运算符，实现对坐标值沿着平行于y=x的向上改变1。编写程序定义Point类，在类中定义整型的私有成员变量x,y；注意函数有无返回值的区别，以及返回值是否带有&引用符号。在类中定义两个友元函数，分别重载前置++和后置++；
C++——运算符重载
最新发布
头秃中。。。。。
10-29 2200
运算符重载：对数据类型已有的运算符重新进行定义赋予另一种功能，以适应不同的数据类型对于内置数据类型，编译器知道如何进行运算int a = 10;int b = 20;//计算机知道如何计算但是如果是两个自定义的类相加计算机就不知道如何计算，因为加号两边不是系统内置的数据结构。
C++编程点滴：C++运算符重载
张亮校的专栏
03-05 1294
C++中预定义的运算符的操作对象只能是基本数据类型，实际上，对于很多用户自定义类型，也需要有类似的运算操作。例如： class complex {  public:   complex(double r=0.0,double I=0.0){real=r;imag=I;}   void display();  private:   double real;   dou
运算符重载
weixin_34326429的博客
09-03 290
前言 1、重载运算符的定义 定义一个重载运算符就像定义一个函数，只是该函数的名字是operator@，这里@代表运算符。比如返回类型 operator << (const class &c){} 2、重载运算符函数参数 重载运算符表中参数的个数取决于两个因素： 运算符本身因素 运算符是一元的（一个参数）还是二元的（两个参数） 运算符定义因素 ...
C++中的操作符重载
jquery教程
09-01 656
一、什么是操作符重载 操作符重载可以分为两部分：“操作符”和“重载”。说到重载想必都不陌生了吧，这是一种编译时多态，重载实际上可以分为函数重载和操作符重载。运算符重载和函数重载的不同之处在于操作符重载重载的一定是操作符。我们不妨先直观的看一下所谓的操作符重载： 1 #include 2 3 using namespace std; 4 5 int main() 6
C++：运算符重载示例
qq_41708281的博客
05-04 427
#pragma once //利用成员运算符重载实现两个复数的加法 class Complex { public: Complex(); Complex(double a, double b); Complex operator +(Complex &rc); //重载运算符 void Display(); ~Complex(); private: double m_real; //实部 double m_imag; //虚部 }; #include "stda.
几个典型运算符重载(C++)(四).ppt
11-13
几个典型运算符重载（C++） 本节主要讲述了C++中几个典型运算符的重载，包括前置和后置形式的++和--运算符的重载。 一、前置和后置形式的++和--运算符的重载 在C++中，可以对++和--运算符进行重载，以便在用户...
C++运算符重载讲解与经典实例 (2).docx
02-27
### C++运算符重载讲解与经典实例 #### 一、引言 在C++编程语言中，运算符重载是一种强大的特性，它允许程序员重新定义内置运算符的行为，以便它们能够应用于自定义数据类型（类或结构）。通过运算符重载，可以使得...
几个典型运算符重载(C++)(四)ppt课件.ppt
11-13
几个典型运算符重载（C++） 本资源主要讲解C++中的运算符重载，特别是几个典型的运算符重载，包括前置和后置的++与--运算符的重载。 1. 运算符重载的概念 运算符重载是指在C++中对已有的运算符重新定义，以适应类...
C++运算符重载函数作为类成员函数和友元函数.pdf
02-27
C++运算符重载是C++语言中一种强大的特性，它允许我们为已经存在的运算符赋予新的含义，以便在自定义的数据类型上使用。运算符重载并不创建新的运算符，而是通过定义一个对应的函数来实现对特定运算符的支持。在C++...
c++运算符重载+实例
Simple_Jan快乐的学习
04-01 1078
题目来源于：http://blog.csdn.net/sxhelijian/article/details/8723847 【项目2拓展2（思考）】这个思考题吊一下大家的胃口：设定义了两个分数类的对象，如CFraction c1, c2。如果定义了int i，我们能用cin>>i>>j;在键盘上输入i和j的值，是否期望用cin>>c1>>c2;输入分数呢？同理，用cout 首先要说明：有的
运算符重载举例
在其位谋其职
05-10 1022
<br />运算符重载的函数一般地采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。 <br /><br />　　1. 重载为类的成员函数 <br /><br />　　这里先举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码： <br /><br />#include ＜iostream.h＞ <br /><br />class complex<br />{<br />public:<b
074-C++
xiaofeng3011的博客
06-09 221
C++ 二元运算符重载 #include using namespace std; class Box { double length; // 长度 double breadth; // 宽度 double height; // 高度 public: double getVolume(void) { return l
C++运算符重载详解及代码示例
weixin_46935110的博客
10-14 2263
c++运算符重载详解及代码示例
C++运算符重载简单举例
qq_39705870的博客
04-12 1204
C++运算符重载简单举例，使用+号重载对象成员的运算。
C++常用运算符的重载及其代码实例
TaloyerG的博客
02-16 893
文章目录一、主要运算符的重载1.赋值运算符 = 的重载2.加号运算符号 + 的重载3.输入输出运算符 << , >>的重载4.判断运算符 == , != 的重载二、运算符重载完整代码实例总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、主要运算符的重载 运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型，其关键字为 operator。下列代码假设我们定义了person类型数据。 1.赋值运算符 = 的重载 person& operat
c++ 运算符重载
m0_64071735的博客
05-25 2076
一、为什么要运算符重载 #include<iostream> #include<string> using namespace std; class ABC { int a, b, c; public: ABC(int x , int y ,int z): a(x),b(y),c(z){} friend ostream &operator << (ostream & out,ABC& f); }; ostream &am
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿基米东

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值