C++难点九：运算符重载

已于 2022-03-10 00:50:41 修改
阅读量461 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 后端
于 2022-02-15 16:43:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43737395/article/details/122947686
版权

文章目录

1. 加号运算符重载

1.1 成员函数

#include <iostream>
#include<string.h>
using namespace std;
//重载加号之成员函数的重载
class Point
{
public:
    int x;
    int y;
    Point():x(1),y(1)
    {
        
    }
    Point operator+(Point &p)
    {
        Point temp;
        temp.x+=p.x;
        temp.y+=p.y;
        return temp;
    }
};

int main()
{
    Point p1;
    Point p2;
    Point p3=p1+p2;
    cout<<p3.x<<" "<<p3.y<<endl;
}

注：Point p3=p1+p2;的本体是Point p3=p1.operator+(p2);为方便记忆，编译器可以帮忙自动转换。

1.2 全局函数

#include <iostream>
#include<string.h>
using namespace std;
//重载加号之成员函数的重载
class Point
{
public:
    int x;
    int y;
    Point():x(1),y(1)
    {
        
    }
   
};

Point operator+(Point &p1,Point &p2)
{
    Point temp;
    temp.x=p1.x+p2.x;
    temp.y=p1.y+p2.y;
    return temp;
}
Point operator+(Point &p1,int num)
{
    Point temp;
    temp.x=p1.x + num;
    temp.y=p1.y;
    return temp;
}
int main()
{
    Point p1;
    Point p2;
    Point p3=p1+p2;
    cout<<p3.x<<" "<<p3.y<<endl;
    Point p4=p1+ 4;
    cout<<p4.x<<" ";
}

2. 左移运算符重载

2.1 成员函数

<<一般不利用成员函数重载，因为cout<<p;一般是cout在左边p在右边，但是如果调用成员函数的话就是p.operator<<cout,编译器会简化成p<<cout;

2.2 全局函数

#include <iostream>
#include<string.h>
using namespace std;
//重载左移运算符之成员函数的重载
class Point
{
public:
    int x;
    int y;
    Point():x(1),y(1)
    {
        
    }
   
};

ostream& operator<<(ostream& cout,Point p)
{
    cout<<"p.x:"<<p.x<<" "<<"p.y:"<<p.y<<endl;
    return cout;
}
//注：要写成返回值是ostream&类型，不然下面的main函数中p1后不能再进行链式编程，如p1<<endl
int main()
{
    Point p1;
    cout<<p1<<endl;
}

注：cout<<p1;的本体是<<(cout,p1)为方便记忆，编译器可以帮忙自动转换。<<(cout,p1)返回的是一个ostream&类型的cout，而cout后面是可以加<<的也就是说，<<(cout,p1)后面又是可以直接加<<的，这也是链式编程的一种思想。

3. 递增运算符重载

目的：我们进行递增运算符重载，是为了让我们自己的数据类型MyInteger能够实现：

MyInteger myInteger；
++ myInteger;//或myInteger++;

3.1 成员函数

3.1.1 前置递增

#include <iostream>
using namespace std;

class MyInteger
{
public:
// 为了让operator能够访问integer.m_integer
    friend ostream& operator<<(ostream& cout,MyInteger integer); 
    MyInteger()
    {
        m_integer = 0;
    }
    // 前置递增 ++a
    MyInteger& operator++()
    {
        m_integer++;
        return *this;//这里的*this代表的是main或者其他函数中由MyInteger m;而创建出来的指向m这个对象的指针
    }  
    int m_integer;
};

// 为了能够 cout<<myinteger;需要先重载一下<<左移运算符
ostream& operator<<(ostream& cout,MyInteger integer)
{
    cout<<integer.m_integer;
    return cout;
}

int main()
{
    MyInteger myinteger;
    cout<<"myinteger:"<<myinteger<<endl;
    cout<<"++myinteger:"<<++myinteger<<endl;
    return 0;
}

3.1.2 后置递增

#include <iostream>
using namespace std;

class MyInteger
{
public:
// 为了让operator能够访问integer.m_integer
    friend ostream& operator<<(ostream& cout,MyInteger integer); 
    MyInteger()
    {
        m_integer = 0;
    }
    // 前置递增 ++a
    MyInteger& operator++()
    {
        m_integer++;
        return *this;//这里的*this代表的是main或者其他函数中由MyInteger m;而创建出来的指向m这个对象的指针
    }
    
    // 后置递增  a++
    MyInteger operator++(int)//这里为什么不用MyInteger返回temp的引用呢？原因很简单。返回局部变量的引用是非法的。
    {
        MyInteger temp = *this;
        m_integer++;
        return temp;
    }
    
    int m_integer;
};

// 为了能够 cout<<myinteger;需要先重载一下<<左移运算符
ostream& operator<<(ostream& cout,MyInteger integer)
{
    cout<<integer.m_integer;
    return cout;
}

int main()
{
    MyInteger myinteger;
    cout<<"myinteger:"<<myinteger<<endl;
    cout<<"++myinteger:"<<++myinteger<<endl;
    cout<<"myinteger++:"<<myinteger++<<endl;
    return 0;
}

3.2 全局函数【是没有的，我自己瞎写的】

3.2.1 前置递增

#include <iostream>
using namespace std;

class MyInteger
{
public:
// 为了让operator能够访问integer.m_integer
    friend ostream& operator<<(ostream& cout,MyInteger &integer); 
    friend MyInteger& operator++(MyInteger& integer);
    MyInteger()
    {
        m_integer = 0;
    }
  
    int m_integer;
};

// 为了能够 cout<<myinteger;需要先重载一下<<左移运算符
ostream& operator<<(ostream& cout,MyInteger &integer)
{
    cout<<integer.m_integer;
    return cout;
}

//++a
MyInteger& operator++(MyInteger& integer)//之所以返回&而不是返回值，因为一直要对一个数据进行操作，比如++(++a)
{
    integer.m_integer++;
    return integer;
}


int main()
{
    MyInteger myinteger;
    cout<<"myinteger:"<<myinteger<<endl;
    cout<<"++myinteger:"<<++myinteger<<endl;
 //   cout<<"myinteger++:"<<myinteger++<<endl;
    return 0;
}

3.2.2 后置递增

a++，似乎是实现不了，因为如果实现的话operator++()里没参数就没办法实现对前面的值++，在网上也没见到有人用全局函数做重载递增的。

4. 赋值运算符重载

与难点六（深拷贝、浅拷贝）一样，这里也会出现深浅拷贝问题，也即开辟在堆区的数据重复析构。我们可以看一下错误的来源：

#include <iostream>
#include <string.h>
using namespace std;

class Person
{
public:
    Person(string name)
    {
        m_name = new string(name);
    }
    
    ~Person()
    {
        if (m_name!=NULL)
        {
            delete m_name;
            m_name=NULL;
        }
    }
    string* m_name;
};

int main()
{
    Person p1("Tom");
    Person p2=p1;
    return 0;
}

不加这个析构函数的时候貌似风平浪静，但是实际上暗流涌动。加上析构，立马表现出与深浅拷贝析构一样的不干净。

解决问题：

#include <iostream>
#include <string.h>
using namespace std;

class Person
{
public:
    Person(string name)
    {
        m_name = new string(name);
    }
    
    Person& operator=(Person& p2)
    {
        if(m_name!=NULL)
        {
            delete m_name;
            m_name=NULL;
        }
        m_name= new string(*p2.m_name);
        return *this;
    }
    
    ~Person()
    {
        if (m_name!=NULL)
        {
            delete m_name;
            m_name=NULL;
        }
    }
    string* m_name;
};

int main()
{
    Person p1("Tom");
    Person p2("Jerry");
    p2=p1;
    cout<<*p2.m_name;
    return 0;
}

注意：这里的重载函数的参数一定要以引用或者指针的形式传入，不然在传入的时候进行了一次拷贝将赋值右边p2的值传入的时候临时变量记录的p2的属性m_Age的地址，而出了赋值运算符重载函数会进行一次析构 这时p2的属性new出来的空间已经被释放了，最后结束调用虽然你深拷贝了但是程序还是会崩
【这地方我也有点迷 学的时候是大半夜迷迷糊糊的 以后找个机会要复习一下】

5. 关系运算符重载

自定义数据类型的比较（相等与不相等）

#include <iostream>
#include <string.h>
using namespace std;

class Person
{
public:
    Person(string str,int Age):name(str),age(Age)
    {
        
    }
   bool operator==(Person &p2)
   {
       if (this->name==p2.name&&this->age==p2.age)
         return 1;
       else 
         return 0;
   }
   
   bool operator!=( Person &p2)
   {
       if (this->name!=p2.name||this->age!=p2.age)
         return 1;
       else 
         return 0;
   }
    
    string name;
    int age;
};

int main()
{
    Person p1("Tom",18);
    Person p2("Tom",19);
    if(p1==p2)
    {
        cout<<"相等"<<endl;
    }
    else 
        cout<<"不相等"<<endl;
    if(p1!=p2)
    {
        cout<<"不相等"<<endl;
    }
    else 
        cout<<"相等"<<endl;    
        
    return 0;
}

6. 函数调用运算符重载（仿函数）

6.1“仿函数”名称的来源

由于调用的格式非常像一个函数，所以又称为仿函数。

#include <iostream>
#include <string.h>
using namespace std;

class Point
{
public:
   void operator()()
   {
       cout<<"operator()的调用"<<endl;
   }
   
   void operator()(string num)
   {
        cout<<"operator(string num)的调用"<<endl;
   }
};

int main()
{
    Point point;
    point.operator()();//原本应该这么调用
    point();//编译器简化以后可以这么调用
    point.operator()("xiaoming");//原本应该这么调用重载函数
    point("xiaoming");//编译器简化后的重载函数的调用
    return 0;
}

6.2 函数的参数列表、返回值都比较灵活

例：

#include <iostream>
#include <string.h>
using namespace std;

class Point
{
public:
   void operator()()
   {
       cout<<"operator()的调用"<<endl;
   }
   
   void operator()(string num)
   {
        cout<<"operator(string num)的调用"<<endl;
   }
   
   int operator()(int a,int b)
   {
       cout<<"int operator()(int a,int b)的调用"<<endl;
       return a+b;
   }
};

int main()
{
    Point point;
    point.operator()();//原本应该这么调用
    point();//编译器简化以后可以这么调用
    point.operator()("xiaoming");//原本应该这么调用重载函数
    point("xiaoming");//编译器简化后的重载函数的调用
    
    cout<<point(3,4);
    return 0;
}

6.3 匿名对象（匿名函数对象）

如果不想创建对象，那就写一个匿名的，当前行执行完立即被释放。而因为里面又有函数重载了一个小括号，所以称之为匿名函数对象。第一个小括号，说明是在创建匿名对象；第二个小括号，说明是在使用重载的()运算符。
例：

#include <iostream>
#include <string.h>
using namespace std;

class Point
{
public:
  void operator()()
   {
       cout<<"operator()的调用"<<endl;
   }
   
   void operator()(string num)
   {
        cout<<"operator(string num)的调用"<<endl;
   }

};

int main()
{
    Point()();
    Point()("xiaoming");//编译器简化后的重载函数的调用
    return 0;
}
PUdd
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习9-运算符重载
sunshine612的博客
03-16 235
运算符重载运算符重载的意义运算符重载为成员函数运算符被重载为全局函数报错原因 运算符重载的意义 运算符重载，就是对已有的运算符赋予多重含义，使同一运算符作用于不同类型的数据时产生不同的行为。运算符重载的目的是使得 C++ 中的运算符也能够用来操作对象。 优点: 如果不做特殊处理，C++的 +、-、*、/ 等运算符只能用于对基本类型的常量或变量进行运算，不能用于对象之间的运算。 有时希望对象之间也能...
C++笔记10：运算符重载
weixin_38665351的博客
08-25 357
123
复习笔记（六）——C++运算符重载（难点）
别呀的博客
04-04 607
目录运算符重载运算符重载的概念运算符重载的定义实例运算符重载的规则一元运算符重载实例自增、自减运算符重载实例二元运算符重载赋值运算符的重载实例‘+’运算符重载的使用实例重载运算符‘[ ]’实例 运算符重载 运算符重载的概念 运算符重载类似于函数重载。 运算符重载允许把标准运算符（如+、-、*、<等）应用于定制数据类型的对象。 什么情况下需要考虑运算符重载？ 需要用运算符操作自定义类的对象时，如对象之间直观自然，可以提高比较大小等，通过重载支持类的运算。 运算符重载：①体现了程序的可读性；②体现了C++
C++学习重难点（三）
m0_63932570的博客
04-01 848
今天我们来看看c++最重要的一个知识点：类与对象。类与对象绝对是c++面向对象的核心。类与对象主要分为三部分：封装，继承和多态。下面一个一个来看吧。 首先public修饰的成员在类外可以直接被访问。protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的) 1.封装：我们使用类将数据和方法都封装起来。不想对外开放的就用 protected/private 封装起来，用 public 封装的成员允许外界对其进行合理的访问。所以封装本质上是一种管理。
C++中的重难点看这一篇就够了
m0_48530561的博客
02-12 2642
sizeof()是一个运算符，不是一个函数 看程序效率的快慢，可以直接看其汇编语言程序的多少 扩展名： c语言：c c++：cpp Java：先有类，再有方法 c++完全兼容c语法 getchar（）等待键盘输入（如果敲回车，就会读取键盘输入） 函数重载（overload） c语言不支持函数重载 两个函数的函数名完全相同，但是函数参数类型，个数，顺序不同 返回值类型不同，不能构成重载 隐式转换（小转大）也可在函数参数类型中适用，但要注意隐式转换有可能产生二义性。 本质： ​采用了na.
C++面向对象（三）：类和对象
Syntactic Sugar
07-26 1564
C++面向对象：类和对象 会有点长，不过读过就全学会喽！！！！！！ 会有点长，不过读过就全学会喽！！！！！！ 会有点长，不过读过就全学会喽！！！！！！ 1.类与对象的基本概念 1.1 结构与类 1 . 结构的扩充 结构是 C 语言的一种自定义的数据类型, 在结构体中可以含有各种不同类型的数 据。C + + 语言对结构类型进行了扩充, 它不仅可以含有不同类型的数据, 而且还可以含有函数。 结构中的数据和函数都是结构的成员,分别称作数据成员和函数成员。在 C + + 中, 通常把 函 数 成 员 称 为 成 员
C++ 类与对象 附加练习题
weixin_52025885的博客
05-22 2636
6-1 Point类的运算 (10 分) 定义Point类，有坐标x,y两个私有成员变量;对Point类重载“+”（相加）、“-”（相减）和“==”（相等）运算符，实现对坐标的改变，要求用友元函数和成员函数两种方法实现。对Point类重载<<运算符，以使得代码 Point p; cout<<p<<endl;可以输出该点对象的坐标。 函数接口定义： 实现Point类。 裁判测试程序样例： /* 请在这里填写答案 */ int main(int argc, cha.
C++实验四.docx
05-22
实验的重点在于掌握运算符重载的成员函数和友元函数实现，而难点在于理解和实现流插入运算符`和流提取运算符`>>`的重载，因为这两个运算符涉及到I/O流的操作，需要对C++的输入/输出流有深入理解。 在完成实验后，...
C语言中文网VIP资料(C++)
02-08
1. **基础语法**：C++的基础语法与C语言相似，包括变量声明、基本数据类型（如int、float、char）、运算符、流程控制（如if语句、for循环、while循环）等。学习C++首先需要熟悉这些基本元素，它们构成了程序的骨架。...
鸡啄米：C++编程入门系列教程
08-26
- 重载函数与函数模板：讲解如何通过函数名的重载实现不同功能，以及函数模板的使用。 4. **类与对象**： - 面向对象设计的基本思想和特点：解释面向对象编程的核心概念，如封装、继承和多态。 - 类的声明、成员...
1_C++基础与提高.zip
10-04
7. **运算符重载**：允许程序员为已有的运算符赋予新的含义，以适应特定类的需求。 8. **模板**：C++的模板提供了一种泛型编程的方式，允许创建能处理多种类型的函数和类。 9. **异常处理**：通过try-catch块来...
C++中常出现的重难点复习题
10-18
10. **不可重载的运算符**：(c) `new`运算符不能被重载，所以选择(c)。 11. **系统定义的标识符**：系统定义的标识符通常是(b)保留字或(c)关键字。 12. **表达式**：由操作符、(b)数据和括号组成，描述计算过程。 ...
C++中的组合
06-21 496
所谓类的组合是指：类中的成员数据是另一个类的对象或者是另一个类的指针或引用。通过类的组合可以在已有的抽象的基础上实现更复杂的抽象。 例如： 1、按值组合 #include #include class Point { public: Point(int xx,int yy)//构造函数 { x=xx; y=yy; cout<<"Point's constructor was c
关于运算符重载的问题
飘零过客
06-28 1176
在设计类的时候，经常用到运算符的重载。运算符 operate<< 重载容易出问题。
[C++]关于重载运算符的一些建议
stary_yan的博客
05-23 5101
运算符1. 谨慎定义类型转换函数有两种函数允许编译器进行这些的转换:单参数构造函数(single-argument constructors)和隐式类型转换运算符。单参数构造函数是指只用一个参数即可以调用的构 造函数。该函数可以是只定义了一个参数,也可以是虽定义了多个参数但第一个参数以后的 所有参数都有缺省值。 第一个例子：class Name { public: Name(const stri
C++看上去好坑的运算符重载
wwxy1995的博客
04-22 3068
总时间限制: 1000ms内存限制: 65536kB描述程序填空#include &lt;iostream&gt; using namespace std; class MyInt { int nVal; public: MyInt( int n) { nVal = n ;}// 在此处补充你的代码}; int Inc(int n) { return n + 1; } int ...
C++运算符重载——看上去好坑的运算符重载
xhluojinji的博客
03-30 1332
就是想把这个程序敲一遍 #include <iostream> using namespace std; class MyInt { int nVal; public: MyInt(int n) { nVal = n}; MyInt & operator-(int n){ //运算符重载- nVal -= n; ...
C++笔试强训7
最新发布
m0_74189279的博客
07-21 970
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
C++程序设计：sizeof运算符详解
此外，熟悉C++的其他核心概念，如指针、引用、运算符重载和动态内存分配等，也是成为熟练C++程序员的必要步骤。通过深入学习和实践，可以克服调试和编程的难点，从而编写出高效、可靠的C++程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值