运算符重载

最新推荐文章于 2022-10-06 00:01:36 发布
最新推荐文章于 2022-10-06 00:01:36 发布
阅读量182 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/richard1230/article/details/79722812
版权

不可重载的几个符号

  • 条件运算符”? :”;例如a=b>c?b:c
  • 指针分量运算符 “->”,例如pstcTest->nNum;
  • 分量运算符”.”,例如stctest.nNum
  • 范围解析运算符”::”
  • 取大小运算符”sizeof”

举个例子来理解:

str .operation<<("1234")
str—->类型
. operation<<—>类比于 函数
("1234")—>类比于 参数列表

成员函数形式运算符重载

  • 单目运算参数表中无参数,调用该函数的对象为操作数
  • 双目运算参数表中有一个参数,调用该函数的对象为第一操作数,参数表中的参数为第二操作数;
  • 运算符函数体会对重载的运算符的含义做出新的解释，这种解释仅仅局限于重载该- 运算符的类之中,脱离类对象,该运算符具有系统预定义的含义

看个例子:

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter() { 
        m_nValue = 0;
    };
    void operator++() {     //1th
    if (m_nValue<65535)
    {
        m_nValue++;
    }
    }
    int operator*() {  //2th
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA;
    ++objA;         //隐式  ;调用1th
    objA.operator++();//显示,调用1th
    cout << *objA << endl;      //调用2处函数
    return 0;
}


#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    };
    void operator+(CCounter &obj) {     //1th

            m_nValue+= obj.m_nValue;

    }
    int operator*() {  //2th
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(5),objB(5);
    objA+objB;          //隐式,调用1th
    objA.operator+(objB);//显示,调用1th
    cout << *objA << endl;  //调用2处函数
    return 0;
}

输出:
15

稍微做了个小改动:

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    };
    void operator+(CCounter &obj) {     //1th

            m_nValue+= obj.m_nValue;

    }
    int operator*() {  //2th
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(5),objB(8);  //此处变成了8
    objA+objB;          //隐式,调用1th
    objA.operator+(objB);//显示,调用1th
    cout << *objA << endl;  //调用2处函数
    return 0;
}

输出:
21

友元函数形式的运算符重载:

单目:

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter() {
        m_nValue = 0;
    };
    friend void operator++(CCounter &obj) {     //1th  由于友元函数不属于此类,故这里要加引用符号
        if (obj.m_nValue < 65535)
        {
            obj.m_nValue++;
        }
    }
    int operator*() {  //2th
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA;
    ++objA;         //隐式，调用1th
    operator++(objA);//显示调用1th,这里需要加objA,这里与1th处与成员函数运算符重载不同!!!
    cout << *objA << endl;      //调用2th处函数
    return 0;
}
输出:2

双目

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    };
    friend void operator+(CCounter &objA,CCounter objB) {       //1th  由于友元函数不属于此类,故这里要加引用符号
                                                                //这里第二个&可以不用加!

            objA.m_nValue+=objB.m_nValue;

    }
    friend int operator*(CCounter obj) {  //2th
        return obj.m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(5),objB(6);
    objA+objB;          //隐式，调用1th
    operator+(objA,objB);//显示调用1th,这里需要加objA,这里与1th处与成员函数运算符重载不同!!!
    cout << *objA << endl;      //调用2th处函数
    return 0;
}
输出:
17

小改动一下:

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    };
    friend void operator+(CCounter &objA,CCounter objB) {       //1th  由于友元函数不属于此类,故这里要加引用符号
                                                                //这里第二个&可以不用加!

            objA.m_nValue+=objB.m_nValue;

    }
    friend int operator*(CCounter obj) {  //2th
        return obj.m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(5),objB(6);
    objA+objB;          //隐式，调用1th
    operator+(objA,objB);//显示调用1th,这里需要加objA,这里与1th处与成员函数运算符重载不同!!!
    cout << *objB << endl;      //调用2th处函数,这里改动为objB,此处与上面不一样
    return 0;
}
输出;6

特殊符号:

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    }
    CCounter(CCounter &obj) {
        m_nValue = obj.m_nValue;
    }

    CCounter& operator=(CCounter &obj) {        //1th

        m_nValue = obj.m_nValue;
        return *this;

    }
    int operator *() {
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(15), objB(5);
    objA = objB;            //隐式,调用1th
    cout << *objA << endl;  //调用2处函数
    return 0;
}
输出:
5

做个改动:

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    }
    CCounter(CCounter &obj) {
        m_nValue = obj.m_nValue;
    }

    CCounter& operator=(CCounter &obj) {        //1th

        m_nValue = obj.m_nValue;
        return *this;

    }
    int operator *() {
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(15), objB(5);
    objA = objB;            //隐式,调用1th
    cout << *objB << endl;  //调用2处函数,这里与上面例子不同
    return 0;
}
输出:5

重新做个改动:(这里需要注意)

这个例子很重要

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter(int nNum) {
        m_nValue = nNum;
    }
    CCounter(CCounter &obj) {
        m_nValue = obj.m_nValue;
    }

    CCounter& operator=(CCounter &obj) {        //1th

        m_nValue = obj.m_nValue;
        return *this;

    }
    int operator *() {
        return m_nValue;
    }

private:
    int m_nValue;
};

int main()
{
    CCounter objA(15), objB(5);
    objB = objA;            //隐式,调用1th,这里是把等号右边传入重载的函数里面!!!!这里需要注意!!!!
    cout << *objA << endl;  //调用2处函数,这里将objA改为objB结果不变！！！！！！！
    return 0;
}
输出:15

objB = objA; //隐式,调用1th,这里是把等号右边传入重载的函数里面!!!!这里需要注意!!!!

 CCounter& operator=(CCounter &obj) {        //1th

        m_nValue = obj.m_nValue;
        return *this;

    }

这里要进行解释一波:

重点:

1.如果返回类型为类类型,即为CCounter,则在执行return这一句话的时候,会再次调用拷贝构造
2.CCounter XXX(临时对象)= *this,这样的话就会调用拷贝构造,因为XXX和*this指的是两个对象(两个对象的话,肯定需要再次开辟内存空间,就会再次调用拷贝构造)；

//全局函数，传入的是对象  !!!!!
void g_Fun(CExample C)                      //6th
{
    cout << "test,执行全局函数了" << endl;
}

1.而如果加了引用的话:
CCounter &XXX(临时对象)= *this,这里*this用A来代替,假设A也是类类型的一个对象,那么此时XXX和A实际上指定是同一个对象,此时就不会再开辟内存空间)

2.参数表里面why是(CCounter &obj)??
其实上面一点已经解释的很到位了,如果不加引用,必然会调用拷贝构造
加引用的效果:
CCounter &obj=objA
不加引用的效果(调用拷贝构造):
CCounter obj=objA

3.返回值为什么为*this??
this是个指针类型,而返回类型为类类型(是个对象),故要对this进行解引用！

特殊运算符二([ ])

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter() {
        for (int i = 0;i<15;i++)
        {
            m_nValue[i] = i;
        }
    }

    int operator [](int nCount) {
        return m_nValue[nCount];
    }

private:
    int m_nValue[15];
};

int main()
{
    CCounter objA;
    for (int i =0;i<15;i++)
    {
        cout << objA[i] <<' ';
    }
    return 0;
}

这里写图片描述

特殊运算符重载：

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CCounter {
public:
    CCounter() {
        memset(m_szStr, 0, sizeof(m_szStr));//0th
    }

    friend ostream& operator<<(ostream& output,CCounter &obj) {//1th
        output << obj.m_szStr;
        return output;

    }

    friend istream& operator>>(istream& input, CCounter &obj) {//2th
        input.getline(obj.m_szStr,15) ;//获取一行的数据(这里指字母或者数字的个数,包括'\0')
                                        //输入的个数大于15,只是获取前面15个!!!
        return input;

    }

private:
    char m_szStr[15];
};

int main()
{
    CCounter obj;       //调用0th处的构造函数
    cin >> obj;  //调用2th
    cout << obj;  //调用1th
    return 0;
}

这里写图片描述

这里写图片描述

richard1230
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++运算符重载
H.T.Yuan的博客
01-11 170
(1)加法运算符重载： #include <iostream> #include <cstring> using namespace std; //运算符重载 //对于内置数据类型，编译器已经预置好 // 1.成员函数实现重载 class Person { public: /* //本质 Person p3 = p1.operator+(p2) Person operator+(Person &p) { this->m_A +=
C++运算符的重载
qq_42174306的博客
02-16 1075
C++运算符重载（operator）
C++核心编程（四）—— 类和对象(5) ：运算符重载
大彤小忆的博客
04-03 3329
5. 运算符重载5.1 加号运算符重载5.2 左移运算符重载5.3 递增运算符重载5.4 赋值运算符重载5.5 关系运算符重载5.6 函数调用运算符重载 5. 运算符重载   运算符重载的概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。   重载的运算符是带有特殊名称的函数，函数名是由关键字operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。   可重载运算符.
VC&operate =操作（重载）解释
suen1987的专栏
06-13 3743
const LLType &operator=(const LLtype&); //这里面的LLType不是一个结构体,而是一个结构体模板,结构体模板是不能定义对象的, 比如下面定义一个结构体模板:templatestruct LLType{//一些数据和函数的声明};在使用的时候必需要有一个类型将这个模板结构实例化后才能定义对象, 比如上面的是以Type类型来实例化这个模板结构,实例化之后
WCF operation的重载
LiuJiang
11-19 839
    很多时候我们用到方法的重载,在WCF中也不例外.不过需要加一点东西.我们以正常的方法来写一个方法的重载,代码如下:    [ServiceContract]    public interface ICalculatorContract    {        [OperationContract]        int add(int x, int y);        [Ope
C++ 运算符重载
热门推荐
qq_27278957的博客
12-26 7万+
前言 本文引用于“C语言中文网”，我整理出来放在博客，方便大家共同学习。所有知识点和代码均已亲测可用，如有疑问，可提出，一起讨论学习。 本章内容： 1. C++运算符重载的概念和原理 2. C++重载=（C++重载赋值运算符） 3. C++深拷贝和浅拷贝（C++深复制和浅复制） 4. C++运算符重载为友元函数 5. C++实现可变长度的动态数组 6. C++重载&lt;&lt;和&gt;...
C++运算符重载详解
qq_52905520的博客
10-06 3万+
C++运算符重载详解
复数运算符重载
03-26
在C#编程语言中，运算符重载是一种特殊的技术，允许程序员为自定义类型赋予标准运算符的新含义。当我们创建一个表示复数的类时，为了使得复数的加法、减法、乘法和除法等操作直观易用，就需要重载相应的运算符。复数...
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
运算符重载运算符重载
10-31
C++类的运算符重载，包括 = ++ -- -(负号运算符) + - * / % == != < > <= >= << >>
python 运算符重载
最新发布
10-10
运算符重载 以Rational class 为例，重载运算符 a/b a//b a += b a == b a a > b a != b a a >= b
c++ operation关键字（重载）
qq_44061866的博客
10-29 1152
https://m.runoob.com/cplusplus/cpp-overloading.html https://www.cnblogs.com/ECJTUACM-873284962/p/6771262.html
C++之operator关键字(重载操作符) 使用总结
码莎拉蒂
03-22 1万+
operator是C++的关键字，它和运算符一起使用，表示一个运算符函数， 一、为什么使用操作符重载 简单的说我们基本数据比如int float 都可以比较大小 有>、、 二、实现重载的操作符 先看简单代码类成员函数实现重载和非类成员函数(全局函数) 1）、操作符重载实现为类成员函数 重载的操作符在类体中被声明，声明方式如同普通成员函数一样，只不
如何使用vs在调试时查看内存--献给初学的你
richard1230的博客
04-06 3万+
鉴于原来写的那篇是没有图片的,当时写的时候markdown使用的也不是太熟练,真是惭愧,今天将原文奉上: 1.调试必须要在Debug状态下进行！ 2.想要查看内存,局部变量等窗口的话，首先要确保在调试状态下（按F5或者按本地windows 调试器）进行，然后点击调试-》窗口-》内存即可；然后弹出一个窗口1，如下： 3.下面讲解怎么看这个内存： int i = 5; ...
如何使用vs在调试时查看内存
richard1230的博客
08-07 2万+
  请看这一篇吧:https://blog.csdn.net/richard1230/article/details/79834473 1.      调试必须要在Debug状态下进行！ 2.想要查看内存,局部变量等窗口的话，首先要确保在调试状态下（按F5或者按本地windows 调试器）进行，然后点击调试-》窗口-》内存即可；然后弹出一个窗口1，如下 3.下面讲解怎么看这个内存： in...
多态与虚函数
richard1230的博客
03-27 2133
1.何为多态???多态的作用?? 2.静态联编和动态联编分别表示什么? 3.类中有虚函数的时候,类有什么变化? 虚函数的几个知识点 几个比较重要的知识点 析构函数为什么要推荐设计为虚函数 下面要注意: 虚基类 有关继承的一句话总结: 1.何为多态???多态的作用?? 多态的概念: 一个接口,多种方法 封装的作用: 封装可以是得代码模块化;继承可以扩展已经存在...
做项目时文件管理的相关总结
richard1230的博客
08-13 898
1一个.cpp文件和一个.h文件构成了一个库;，也即是一个模块，一般而言，一个项目是由一个main..cpp文件和若干个模块组成的; 2.同一个类型或者同一个功能的代码，用一个.cpp文件和.h文件保存。 3.(.h)头文件中不能有可执行代码，也不能有数据的定义，只能有宏，类型(typedef,struct,union),数据和函数的声明(这里的宏，类型，数据和函数都可以被其他文件所用，但是这
构造函数
richard1230的博客
03-27 299
构造函数 构造函数的意义 必须要初始化成员变量情况 注:初始化列表在冒号后面 :初始化列表的顺序:按照成员变量定义的顺序进行初始化: 调用构造函数的顺序 小结: 有参与无参构造的对比 构造函数的特征: 默认构造函数的特征: 析构函数 析构函数特点 析构函数调用顺序 小结: 具有继承关系的类之间的构造和析构调用顺序 拷贝构造 特征: 这里why为引用类型？ 拷贝构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值