C++中的运算符重载

已于 2022-02-20 17:17:41 修改
阅读量1.5k 收藏 7
点赞数 1
分类专栏： C++ primer 文章标签： c++ 开发语言 后端
于 2022-02-20 17:09:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50697073/article/details/123020668
版权

文章目录

C++中的运算符重载（operator overload）

  • 运算符重载（操作符重载）：可以为运算符增加一些新的功能；
1. +

方法一：

class Point {
public:
      int m_x;
      int m_y;
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};
Point operator+(const Point &p1, const Point &p2) { //const型参数可以接受const和非const实参，&可以避免中间对象的生成
     return Point(p1.m_x + p2.m_x, p1.m_y + p2.m_y);
}

在这里插入图片描述
方法二（重载函数写到类里面）

class Point {
public:
      int m_x;
      int m_y;
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      const Point operator+(const Point &point) const{ 
           return Point(m_x + point.m_x, m_y + point.m_y); //因为const对象不能调用非const函数，所以应用常量函数；而且不允许a + b = 10类赋值，所以同理应返回const对象
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};
  • 全局函数、成员函数都支持运算符重载。
2. -
class Point {
public:
      int m_x;
      int m_y;
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      const Point operator+(const Point &point) const{ 
           return Point(m_x - point.m_x, m_y - point.m_y); //因为const对象不能调用非const函数，所以应用常量函数；而且不允许a - b = 10类赋值，所以同理应返回const对象
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};
3. += 和 -=

+=:

class Point {
public:
      int m_x;
      int m_y;
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      Point &operator+=(const Point &point) { //返回引用型对象，可以避免中间对象；
      C++允许 a+=b = 10，所以不用返回常对象
          m_x += point.m_x;
          m_y +=  point.m_y;
          return *this;
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }

-=：

class Point {
public:
      int m_x;
      int m_y;
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      Point &operator-=(const Point &point) { //返回引用型对象，可以避免中间对象；
      C++允许 a+=b = 10，所以不用返回常对象
          m_x -= point.m_x;
          m_y -=  point.m_y;
          return *this;
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
4. ==和!=

==:

class Point {
      int m_x;
      int m_y;
public:
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      bool operator==(const Point &point) { 
          if(m_x == point.m_x && m_y == point.m_y)
              return true;
          else 
              return false;
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }

-=:

class Point {
      int m_x;
      int m_y;
public:
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      bool operator!=(const Point &point) { 
          if(m_x != point.m_x || m_y != point.m_y)
              return true;
          else 
              return false;
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
5. 其他：关于拷贝构造函数中的“&”
Point(const Point &point) { //相当于把p1的地址值传入了
        m_x = point.m_x;
        m_y = point.m_y;
}

Point p1;
Point p2 = p1; //调用拷贝构造函数

但是：

Point(const Point point) { //当接受p1时，Point p = p1，会再次调用拷贝构造函数，成为了死循环
        m_x = point.m_x;
        m_y = point.m_y;
}

Point p1;
Point p2 = p1; //调用拷贝构造函数
6. 单目运算符

-：

class Point {
      int m_x;
      int m_y;
public:
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      const Point operator-() const{ 
           return Point(-m_x, -m_y); //因为允许(-(-x))
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }

前置++:

class Point {
      int m_x;
      int m_y;
public:
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      Point & operator++() { 
           m_x ++;
           m_y ++;
           return *this;
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};

后置++：

class Point {
public:
      int m_x;
      int m_y;
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      const Point operator++(int) {  //允许b = a ++ + 1，但不允许a ++ = 1；
          Point old(m_x, m_y);
           m_x ++;
           m_y ++;
           return old;
      }
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};

同理 --。

7. 输出与输出

输出：

class Point {
      friend ostream &operator<<(ostream &, const Point &);
      int m_x;
      int m_y;
public:
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};

ostream &operator<<(ostream &cout, const Point &point) {
      cout << "(" << point.m_x << "," << point.m_y << ")" << endl;
      return cout; //返回cout对象，才能使用cout << a << b。实现多次重载;
 }

输入：

class Point {
      friend istream &operator>>(istream &, Point &);
      int m_x;
      int m_y;
public:
      Point(int x, int y) :m_x(x), m_y(y) { }
      Point(const Point &point) :m_x(point.m_x), m_y(point.m_y) { }  //const型参数可以接受const和非const实参，&可以避免中间对象的生成
      void display() {
            cout << "x = " << this->m_x << ", y = " << this->m_y << endl;
       }
};

istream &operator>>(istream &cin, Point &point) { //因为point对象允许被修改，所以不应该是const型对象（const对象不允许修改）
      cin >> point.m_x;
      cin >> point.m_y;
      return cin;
 }

调用父类的运算符重载函数

class Person {
       int m_age;
public:
       Person &operator=(const Person &person) {
                    this->m_age = person.m_age;
       }
};
class Student : public Person {
        int m_score;
public:
        Student &operator= (const Student & student) {
               Person::operator=(student);
               this->m_score = student.m_score;
         }

单例模式扩充

class Rocket {
private:
  Rocket() {}
 ~Rocket() {}  //防止用户在生成Rocket中delete掉对象
 static Rocket *ms_rocket;
 void operator=(const Rocket &rocket) { }  //重载赋值运算符，不允许赋值
public:
 static Rocket *sharedRockert() {
     //这里要考虑多线程安全
       if (ms_rocket == NULL) { 
              ms_rocket = new Rocket();
        }
        return  ms_rocket;
  }
  static void deleteRocket() {
       // 这里要考虑多线程安全
       if (ms_rocket != NULL) {
           delete ms_rocket;  //只是堆空间的对象被释放了
           ms_rocket = NULL;  //ms_rocket指针仍然还在栈中，不会清零
        }
   }
};
Rocket *rocket::ms_rocket = NULL;

仿函数（函数对象）

  • 仿函数：将一个对象当成一个函数一样来使用。
class Sum {
public:
      int operator() (int a, int b) {
          return a + b;
     }
};

Sum sum;
cout << sum(20, 30) << endl;
  • 对比普通函数，它作为对象可以保存状态。

运算符重载注意点

  • 有些运算符不可以被重载，比如：
  1. 对象成员访问运算符：.
  2. 域运算符：::
  3. 三目运算符：?:
  4. sizeof
  • 有些运算符只能重载为成员函数，比如：
    1. 赋值运算符：=
    2. 下标运算符：[]
    3. 函数运算符：（）
    4. 指针访问成员：->
Balaaam
关注
专栏目录
C++：运算符的重载
CSDN
07-15 593
运算符重载 运算符重载 对已有的运算符赋予多重的含义 使同一运算符作用于不同类型的数据时有不同类型的行为 目的： 扩展cpp中提供的运算符的适用范围, 以用于类所表示的抽象数据类型 运算符重载的实质是函数重载，参数个数为运算符目数 返回值类型 operator 运算符(形参表) { …… } 在程序编译时： 把含运算符的表达式 -> 对运算符函数的调用 把运算符的操作数 -&...
C++运算符重载
鬼谷子的博客
03-21 334
C++运算符重载 运算符重载概念：即给原有运算符赋予新功能。 比如，c++中的以下操作便是用到了重载运算符： #include<string> #include<iostream> using namespace std; int main(void) { string str1("hello"); string str2("world"); string str3...
C++中运算符重载
weixin_34368949的博客
07-06 95
概述：运算符重载是C++多态的重要实现手段之一。一般而言，对于双目运算符，最好将其重载为友元函数；而对于单目运算符，则最好重载为成员函数。但是一定要记得其中的例外情况。 运算符重载的四项基本原则： a.不可臆造运算符。 b.运算符原有操作数的个数、优先级和结合性不能改变。 c.操作数中至少一个是自定义类型。 d.保持重载运算符的自然含义。 ...
C++中operator关键字（重载操作符）
最新发布
木牛的博客
07-31 535
operator是C++的关键字，它和运算符一起使用，表示一个运算符函数，理解时应将operator=整体上视为一个函数名。这是C+ +扩展运算符功能的方法，虽然样子古怪，但也可以理解：一方面要使运算符的使用方法与其原来一致，另一方面扩展其功能只能通过函数的方式（c++中，“功能”都是由函数实现的)。
C++中的 运算符重载
qq_24472227的博客
04-09 3667
C++的 各种运算符重载：加号、左移、递增、赋值、关系、函数调用
C++——运算符的重载
热门推荐
weixin_59179454的博客
05-30 1万+
运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。让类类型的对象像基本数据类型一样去操作 例如：可以实现对象+,-* / % ==!运算符的重载实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该重载的运算符时调用此函数。这个函数叫做运算符重载函数，通常为类的成员函数。定义运算符重载函数的一般格式：返回值类型 类名::operator重载的运算符(参数表) {……}operator是关键字，它与重载的运算符一起构成函数名。
C++运算符重载（操作符重载）
qq_41885018的博客
05-11 1257
有时候我们需要让对象之间进行运算， C++ 提供的“运算符重载”机制，赋予运算符新的功能，就能解决用+将两个复数对象相加这样的问题。，因为左移运算符左边是cout，而想要调用类里的成员函数首先要是对象才行，而cout显然不是对象，括号运算符()也可以重载，对象名可以当成函数来使用（函数对象、仿函数）。除了 “ + ”，还有其他的运算符重载，如 “ - ”（减法运算）接着刚才的问题，我们利用运算符重载为运算符增加一些新的功能，，既可以接受const对象，也可以接受非const对象。
C++赋值运算符重载
wo_ai_luo_的博客
11-05 3136
但是当类持有其它资源时，例如动态分配的内存、打开的文件、指向其他数据的指针、网络连接等，默认的赋值运算符就不能处理了，我们必须显式地重载它，这样才能将原有对象的所有数据都赋值给新对象。是一个指针，里面存放的是指向存储 age 内容的地址，不重载赋值运算符时，使用默认的赋值运算符时这是把 people1的 mp_age指针里存放的地址赋值给了people2的mp_age指针导致两个指针指向了同一块内存空间，这时候默认赋值运算符的不足就满足不了实际的需求了，需要重载赋值运算符。​ 在前面的内容中讲解。
c++中 运算符重载 const 函数
H_Strong的博客
11-10 4667
概要 本篇文章主要内容是关于运算符重载，然后在最后提了一下 const修饰函数时的状况。后面会补上一个日期类的定义。 文章目录概要赋值运算符的重载= 号的重载i++ 和 ++i 前置与后置++的区别const 修饰函数 赋值运算符的重载 函数可以重载，在 C++ 中可以使用赋值运算符的重载。 函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 函数名字为：关键字operator后面接需...
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
详解C++编程中的单目运算符重载与双目运算符重载
01-20
C++单目运算符重载 单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和–i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数...
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
C++研发 核心篇 第四讲 【4.5 运算符重载】
Kukeoo的博客
02-12 110
4.5 运算符重载 运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 4.5.1 加号运算符重载 作用：实现两个自定义数据类型相加的运算 class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m_B = b; } //成员函数实现 + 号运算符重载 Person operator+(const Person& p) {
c++的++运算符重载
dancheng1的博客
02-14 317
成员函数实现 #include using namespace std; class AA { private: int c; public: AA(int x1) { c=x1; //定义前缀和后缀的唯一区别是定义的括号里后缀多了一个int。 } AA operator++(int) //后缀 { AA s=*this;
C++_运算符重载
刘同学的博客
05-05 235
1. 友元函数： 作用： 可以在函数外部直接访问私有成员，但是友元破坏封装性 格式： （类内）friend 函数类型 函数名（参数列表）； （类外）函数类型 函数名（参数列表）{函数体}； 说明： 友元不属于成员函数，在类外实现时不需要加上类解析（A::） 没有this指针，不受访问权限的控制 友元类： 格式： class 类名1{friend class 类名2...
C++类的运算符重载
Jasmine-Lily的博客
11-19 3543
C++类的运算符重载
C++运算符重载详解
C++中的运算符重载是编程中一个重要的概念，它允许程序员根据需要为自定义数据类型扩展运算符的功能。在C++中，运算符重载是通过定义特定的成员函数或友元函数来实现的，目的是使得用户定义的类型能够像内置类型一样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Balaaam

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

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

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

打赏作者

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

抵扣说明：

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

余额充值