运算符重载

程序员文章站 2022-05-18 16:34:08

...

不可重载的几个符号

条件运算符”? :”;例如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;
}

运算符重载

上一篇： grpc实战——客户端流式调用

下一篇：运算符重载

运算符重载

不可重载的几个符号

举个例子来理解:

成员函数形式运算符重载

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

单目:

双目

特殊符号:

这个例子很重要

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

重点:

特殊运算符二([ ])

特殊运算符重载：

mysql运算符大全、优先级及实例讲解

qt5 connect写法遇到重载的函数和信号槽

http://www.56.com/m2v/?magic=1 有关php运算符的知识大全

QT5槽函数有重载情况下连接信号与槽

Qt5中信号槽函数重载问题的两种解决办法

Qt5 connect 使用之“重载信号和槽”

Mybatis接口Mapper内的方法为啥不能重载？Mapper的源码分析

有关php运算符的知识大全_PHP教程

javascript基础课程之运算符定义用法详解

PHP面向对象编程之深入理解方法重载与方法覆盖（多态），_PHP教程