操作符重载（下）

最新推荐文章于 2022-07-08 18:01:34 发布
最新推荐文章于 2022-07-08 18:01:34 发布
阅读量202 收藏
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ1402369668/article/details/104435688
版权

文章目录

类的成员函数是否可以作为操作符重载的函数？

通过operator关键字能够将操作符定义为全局函数

操作符重载的本质就是函数重载

类的成员函数是否可以作为操作符重载的函数？

A：当然可以

#include <cstdlib>
#include <iostream>

using namespace std;

class Complex
{
    int a;
    int b;
public:
    Complex(int a, int b)
    {
        this->a = a;
        this->b = b;
    }       
    
    Complex operator+ (const Complex& c2); //成员函数：+操作符重载 
    									   //注意：此处有一个隐藏参数：this指针 
    
    friend ostream& operator<< (ostream& out, const Complex& c);
};

//复习：当无法修改左操作数的类时，使用全局函数进行重载(例如：ostream的<<操作符，在标准库中，无法修改ostream类)
ostream& operator<< (ostream& out, const Complex& c)
{
    out<<c.a<<" + "<<c.b<<"i";
    
    return out;
}

Complex Complex::operator+ (const Complex& c2) //成员函数：+操作符重载 
											   //成员函数的操作符重载  比 全局函数的操作符重载 要 少一个参数，其实可以理解为this指针替代了 
{
    Complex ret(0, 0);
    
    ret.a = this->a + c2.a;
    ret.b = this->b + c2.b;
    
    return ret;
}

int main(int argc, char *argv[])
{
    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = c1 + c2; //相当于 c1. operator+ (c2);
    
    cout<<c1<<endl;
    cout<<c2<<endl;
    cout<<c3<<endl;
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

在这里插入图片描述

用成员函数重载的操作符

比全局操作符重载函数少一个参数，即左操作数
不需要使用friend关键字

在这里插入图片描述

什么时候使用全局函数重载操作符？什么时候使用成员函数重载操作符？

当无法修改左操作数的类时，使用全局函数进行重载(例如：ostream的<<操作符，在标准库中，无法修改ostream类)

=, [], ()和->操作符只能通过成员函数进行重载

重载=, []操作符有什么用哪？

数组类的改进

重载[]操作符

int& operator[](int i);

int& Array::operator[](int i)
{
    return mSpace[i];
}

//调用
for(int i=0; i<a1.length(); i++) //赋值
{
    a1[i] = i + 1;
}

for(int i=0; i<a1.length(); i++) //取值
{
    printf("Element %d: %d\n", i, a1[i]);
}

重载=操作符

Array& operator= (const Array& obj);
 
Array& Array::operator= (const Array& obj) //返回引用Array&是为了支持 链式赋值 a1 = a1 = a3
{
    delete[] mSpace; //delete之前的内存
    
    mLength = obj.mLength;
    
    mSpace = new int[mLength]; //深拷贝    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
    
    return *this;
}

//调用
Array a1(10);
Array a2(0);
Array a3(0);

a3 = a2 = a1;

重载==操作符

bool operator== (const Array& obj);

bool Array::operator== (const Array& obj)
{
    bool ret = true;
    
    if( mLength == obj.mLength )
    {
        for(int i=0; i<mLength; i++)
        {
            if( mSpace[i] != obj.mSpace[i] )
            {
                ret = false;
                break;
            }
        }
    }
    else
    {
        ret = false;
    }
    
    return ret;
}

//调用
if( a1 == a2 )
{
    printf("a1 == a2\n");
}

数组类：最终完整代码

Array.h


#ifndef _ARRAY_H_
#define _ARRAY_H_

class Array
{
private:
    int mLength;
    int* mSpace;

public:
    Array(int length);
    Array(const Array& obj);
    int length();
    ~Array();
    int& operator[](int i);
    Array& operator= (const Array& obj);
    bool operator== (const Array& obj);
    bool operator!= (const Array& obj);
};

#endif

Array.cpp

#include <stdio.h>
#include "Array.h"

Array::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    
    mLength = length;
    mSpace = new int[mLength];
}

Array::Array(const Array& obj)
{
    mLength = obj.mLength;
    
    mSpace = new int[mLength];
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

int Array::length()
{
    return mLength;
}

Array::~Array()
{
    mLength = -1;
    printf("%08X\n", mSpace);
    delete[] mSpace;
}

int& Array::operator[](int i)
{
    return mSpace[i];
}

Array& Array::operator= (const Array& obj)
{
    delete[] mSpace;
    
    mLength = obj.mLength;
    
    mSpace = new int[mLength];
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
    
    return *this;
}

bool Array::operator== (const Array& obj)
{
    bool ret = true;
    
    if( mLength == obj.mLength )
    {
        for(int i=0; i<mLength; i++)
        {
            if( mSpace[i] != obj.mSpace[i] )
            {
                ret = false;
                break;
            }
        }
    }
    else
    {
        ret = false;
    }
    
    return ret;
}

bool Array::operator!= (const Array& obj)
{
    return !(*this == obj);
}

main.cpp

#include <stdio.h>
#include "Array.h"

int main()
{
    Array a1(10);
    Array a2(0);
    Array a3(0);
    
    if( a1 != a2 )
    {
        printf("a1 != a2\n");
    }
    
    for(int i=0; i<a1.length(); i++)
    {
        a1[i] = i + 1;
    }
    
    for(int i=0; i<a1.length(); i++)
    {
        printf("Element %d: %d\n", i, a1[i]);
    }
    
    a3 = a2 = a1;
    
    if( a1 == a2 )
    {
        printf("a1 == a2\n");
    }
    
    for(int i=0; i<a2.length(); i++)
    {
        printf("Element %d: %d\n", i, a2[i]);
    }
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

C++编译器会为每个类提供默认的赋值操作符=

C++编译器会为每个类提供默认的赋值操作符
默认的赋值操作符只是做简单的值复制
类中存在指针成员变量时就需要重载赋值操作符

#include <cstdlib> 
#include <iostream>

using namespace std;

class Test{
public:	
	Test(int a) {
		cout <<"Test()" <<endl; 
		
		m_a = a;
	}
	
	Test(const Test& obj){
		this->m_a= obj.m_a;
		
		cout << "Test(const Test& obj)" <<endl;
	}
	
	Test& operator= (const Test& t) {
		this->m_a = t.m_a;
		
		cout << "Test& operator= (const Test& t) " <<endl;
	}
	
	void printA(){
		cout << "printA(): "<<m_a <<endl;
	}
private:
	int m_a;	
}; 

int main()
{
	Test t1(1);
	Test t2(2);
	
	t2 = t1; //注意 ：此时调用Test& operator= (const Test& t) 函数，而非拷贝构造函数！！！
	t2.printA();
	
	return 0;
}

在这里插入图片描述

++操作符重载

++操作符只有一个操作数
++操作符有前缀和有后缀的区分

问题：如何重载++操作符才能区分前置运算和后置运算？

操作符重载是通过函数重载实现的

​ C++中通过一个占位参数来区分前置运算和后置运算

部分代码

Complex operator++ (int); //obj++
Complex operator++ (); //++obj

Complex Complex::operator++ (int)
{
	Complex ret = *this; //记录一下当前的值
    
    a++;
    b++;
    
    return ret;
}


Complex Complex::operator++ ()
{
	++a;
    ++b;
    
    return *this;
}

全部代码：

#include <cstdlib>
#include <iostream>

using namespace std;

class Complex
{
    int a;
    int b;
public:
    Complex(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    
    int getA()
    {
        return a;
    }
    
    int getB()
    {
        return b;
    }
    
    Complex operator+ (const Complex& c2); 
    Complex operator++ (int);  //obj++
    Complex& operator++(); ++obj
    
    friend ostream& operator<< (ostream& out, const Complex& c);
};

ostream& operator<< (ostream& out, const Complex& c)
{
    out<<c.a<<" + "<<c.b<<"i";
    
    return out;
}

Complex Complex::operator++ (int)
{
    Complex ret = *this;
    
    a++;
    b++;
    
    return ret;
    
}

Complex& Complex::operator++()
{
    ++a;
    ++b;
    
    return *this;
}

Complex Complex::operator+ (const Complex& c2)
{
    Complex ret(0, 0);
    
    ret.a = this->a + c2.a;
    ret.b = this->b + c2.b;
    
    return ret;
}

int main(int argc, char *argv[])
{
    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = c2;
    
    c2++;
    ++c3;
    
    cout<<c1<<endl;
    cout<<c2<<endl;
    cout<<c3<<endl;
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

不要重载&&和||，为什么？

#include <cstdlib>
#include <iostream>

using namespace std;

class Test
{
    int i;
public:
    Test(int i)
    {
        this->i = i;
    }
    
    Test operator+ (const Test& obj)
    {
        Test ret(0);
        
        cout<<"Test operator+ (const Test& obj)"<<endl;
        
        ret.i = i + obj.i;
        
        return ret;
    }
    
    bool operator&& (const Test& obj)
    {
        cout<<"bool operator&& (const Test& obj)"<<endl;
        
        return i && obj.i;
    }
};

int main(int argc, char *argv[])
{
    int a1 = 0;
    int a2 = 1;
    
    if( a1 && (a1 + a2) ) //&&的短路规则，(a1+a2)将不会执行
    {
        cout<<"Hello"<<endl;
    }
    
    Test t1 = 0;
    Test t2 = 1;
    
    if( t1 && (t1 + t2) ) //等价于 ti. operator&& (t1. operator+ (t2) ) 
    {
        cout<<"World"<<endl;
    }
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

在这里插入图片描述

&&和||是C++中非常特殊的操作符
&&和||内置实现了短路规则
操作符重载是靠函数重载来完成的
操作数作为函数参数传递
C++的函数参数都会被求值，无法实现短路规则

小结

操作符重载可以直接使用类的成员函数实现
=, [], ()和->操作符只能通过成员函数进行重载
++操作符通过一个int参数进行前置与后置的重载
C++中不要重载&&和||操作符

tsfg
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++初阶讲解—运算符重载汇总+实例（上）
m0_57781768的博客
11-17 1354
运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
用成员函数和友元函数重载运算符
代码黑洞
05-20 3503
友元函数和成员函数选择 1.当无法修改左操作数的类时，使用全局函数进行重载 2.=、[]、()和->操作符只能通过成员函数进行重载 用友元函数重载<<、>>操作符 ostream& operator<<(ostream &out, Complex &c) istream& operator>>(istr...
10. C++操作符重载
zhubao124的博客
11-10 993
在介绍C++中操作符重载之前，先介绍下C++标准库。 一、C++标准库 1. C++标准库并不是C++语言的一部分； 2. C++标准库是由C++语言编写而成的类库和函数的集合； 3. C++标准库中定义的类和对象都位于std命名空间中； 4. C++标准库的头文件都不带.h后缀；...
C++ 函数
weixin_30240349的博客
09-08 234
函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数main()，所有简单的程序都可以定义其他额外的函数。 您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。 函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。 C++ 标准库提供了大量的程序可以调用的...
C++ 的this指针
ms347397173的博客
11-27 410
this指针用于类的非静态成员函数在访问非静态成员变量时由编译器自动加入的一个参数，this是指向调用函数的对象的指针。 怎么理解呢? 首先，this只能是一个类的对象在需要访问自己的成员变量时调用成员函数，这时候编译器会为函数自动加入一个名字叫做this的参数，类型为【类名的指针】 举例： #include using namespace std; class Date { pub
C++操作符重载
01-20
重载操作符是具有特殊名称的函数：保留字operator后接需定义的操作符符号。... 　下面通过实例说明操作符重载 　源代码下载：点击下载。 　1、算术操作符 　定义一个Point类，Point.h头文件： // Point.
C++中的操作符重载详细解析
09-05
在C++编程语言中，操作符重载是一种重要的特性，它允许程序员为自定义类型赋予新的操作符含义，使得操作符能以与内置类型类似的方式处理用户定义的类。但必须注意，操作符重载不能改变操作符原有的操作数个数，例如...
详解C++赋值操作符重载
01-19
1.赋值操作符重载的原因 赋值操作符是一个使用频率最高的操作之一，通常情况下它的意义十分明确，就是将两个同类型的变量的值从一端（右端）传到另一端（左端）。但在以下两种情况下，需要对赋值操作符进行重载。 一...
Python中操作符重载用法分析
09-21
### Python中操作符重载用法分析 #### 一、操作符重载概述 操作符重载是Python中一个非常强大的特性，它允许我们自定义类的行为，使其能够支持类似于内置类型的操作。通过操作符重载，我们可以为自定义类添加如...
C++输入输出操作符重载的深入分析
09-05
在C++编程语言中，操作符重载是一种强大的特性，允许程序员为自定义类型赋予新的操作符含义。本文将深入探讨C++中的输入输出操作符重载，这对于理解和使用自定义类型进行I/O操作至关重要。 首先，理解操作符重载的...
this 关键字
m0_51942099的博客
03-03 372
this指针: 在C++中，每个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。 1 . 每个成员函数内部（包括构造和析构）都有一个this指针；this指针指向调用对象，即可通过this关键字访问当前对象的成员 访问成员变量 this->成员名; 访问成员函数 this->函数名(); public: void InitScores(); //初始化学生成绩数组，默认分配1个元素空间 void AddScore(flo
关于this this()
lisiqi666的博客
07-17 446
关于this this的第一个作用：区分局部变量和成员变量 this的第二个作用：指代对象本身 方法的调用必须通过对象才能进行 public class Point { private int row; private int col; public void setRow(int row) { if(row<=0 || row>25) { row=1; ...
对C++中的this指针的分析
我的大学
09-25 569
一个示例首先让我们观察如下代码：namespace ClassTest { class A { private: int m_int1; int m_int; static int st_int; public: void test1() { cout << "test1" << endl; }
this.的两种用法
zhu54326的博客
08-18 488
this是什么
C++中这种写法：[this](int a, int b)
zhangyikuaile的博客
04-01 746
类成员函数定义： int testClass::test() { auto getNum = [this](int a, int b){ return (a-b); }; int c = getNum(5, 4); return c; } 这是一个lambda表达式，等价于： intanonymous_function(inta,intb) { return(a-b); } autogetNum=anonymous_function; 并且捕获了this指针，可以...
浅析C++中的this指针
热门推荐
寒星轩
01-24 6万+
     有下面的一个简单的类：class CNullPointCall{public:    static void Test1();    void Test2();    void Test3(int iTest);    void Test4();private:    static int m_iStatic;    int m_iTest;};int CNullPointCal
vue.js使用this[ ]()动态获取方法
lemon今天学习了吗？的博客
07-08 3814
使用this[ ]()写法，在[ ]内填入变量，即可调用不同的方法；this.$refs[ ]同样适用。 关于this.$refs的使用，先来介绍一下：介绍：只要想要在Vue中直接操作DOM元素，就必须用ref属性进行注册。$refs与document.getElementById方法相比，会减少获取DOM节点的消耗。用法：强调：如果有多个this.$refs需要动态被使用，就可以通过this.$refs[ ]这种方法在[ ]中传入要动态改变的名字。...
this()的用法 | B站Java学习笔记
seven_study_log的博客
01-15 3576
this除了可以使用在实例方法中，还可以用在构造方法中 新语法：通过当前的构造方法去调用另一个本类的构造方法，可以使用以下语法格式： this(实际参数列表) this() 这个语法作用是什么？ 回答：代码复用 重点 死记硬背 只能出现在构造方法的第一句 只能出现一次，不能出现两次 需求： – 定义一个日期类，可以表示年月日信息 – 需求中要求： 如果调用无参数构造方法，默认创建的日期为：1970年1月1日 当然，除了调用无参数构造方法之外，也可以调用有参数的构造方法来创建日期对象 class Date.
C++中this指针详解（写的不错）
小米的修行之路
09-03 1万+
this指针 在建立对象时，系统会为每一个对象分配独立的存储空间,也就是给每个对象中的数据成员都分配有自己独立的存储空间。如果对同一个类定义n个对象，则有n组同样大小的空间以存放对象中的数据成员。但对于成员函数来说，对象中的数据成员。一个函数的代码段在内存中只有一份。也就是说，函数的代码段在内存中只有一份。也就是说，同一个类中的不同对象在调用自己的成员函数时，一个类中的不同对象在调用自己的成
C++友元与操作符重载教程详解
C++操作符重载是C++编程中一个重要的高级特性，它允许程序员自定义特定操作符的行为，以适应类或结构体的内部逻辑。在这个PPT教程中，由讲师朱景尧讲解，主要涵盖两个核心主题：友元和操作符重载。 1. **友元机制**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值