C++深入理解（一）——自定义类中重载运算符返回引用以及连续赋值的机制理解

最新推荐文章于 2024-12-03 19:22:22 发布
最新推荐文章于 2024-12-03 19:22:22 发布
阅读量2.1k 收藏 16
点赞数 9
CC 4.0 BY-SA版权
文章标签： C++ 运算符重载返回的类型 自定义类对象连续赋值的过程分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/holmes_MX/article/details/87630237
本文探讨了C++中自定义类的运算符重载，特别是赋值运算符的实现方式，对比了返回对象和返回引用的区别。通过具体示例，分析了不同返回类型对连续赋值操作的影响，以及拷贝构造函数的调用情况。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

0. 写作目的

好记性不如烂笔头。

结论：在自定义的类中，运算符重载需要返回类对象的引用。如果返回的是类对象，则在赋值的过程中会调用拷贝构造函数，引起不必要的运算。如果返回的是void，则不能进行连续赋值（如a = b = c）。

（补充：在自定义类的对象连续赋值中a = b = c（a,b,c均为新定义的类的实例），

当运算符重载函数返回的是类对象引用时，其过程为，b = c调用运算符重载函数，返回b的引用，然后a = b调用运算符重载函数，返回a 的引用。

当运算符重载函数返回的是类对象时，其过程为，b = c先调用运算符重载函数，该函数结束后，由于返回的是类对象，因此在a = b = c这行代码中会创建一个临时类对象tem_c，用于接收运算符重载之后的结果，此时会调用拷贝构造函数tem_c( *this )，其中this是运算符重载函数中的。同时a = tem_c调用运算符重载函数，然后在a = b = c创建一个临时类对象tem_a，然后调用拷贝构造函数tem_a( *this )，然后释放tem_a（析构函数），再释放tem_c（析构函数））。

（补充2：自定义的类，C++编译器会自动创建6个函数，其中（默认的move constructor 和 默认的move assignment operator函数是从C++11之后有的，由于平时不采用这两种函数进行赋值，因此不对此进行考虑）。主要关注其余4中默认函数——默认构造函数（default constructor），拷贝构造函数(copy constructor)，赋值运算符重载函数(copy assignment operator)和析构函数(Destructor) [1]。）

1. 运算符重载返回对象

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

class CStudent
{
public:
    CStudent(char *pName) :m_pName(NULL)
    {
        if (NULL == pName)
        {
            return;
        }
        m_pName = new char[strlen(pName) + 1];
        strcpy(m_pName, pName);
        printf("CStudent: address:0x%08x name:%s\n", this, m_pName);
    }
    ~CStudent()
    {
        printf("~CStudent: address:0x%08x name:%s\n", this, m_pName);
        delete []m_pName;
    }
    //拷贝构造函数
    CStudent(const CStudent &a) :m_pName(NULL)
    {
        if (NULL == a.m_pName)
        {
			cout<<"reference"<<endl;
            return;
        }
        int len = strlen(a.m_pName);
        this->m_pName = new char[len + 20];
        memset(m_pName, 0, len + 20);
        strcpy(m_pName, a.m_pName);
        strcat(m_pName, "_copy_construct"); // 为了测试
        printf("copy construct: address:0x%08x name:%s\n", this, this->m_pName);
    }
public:
#if 1
    //重载赋值函数   返回对象
    CStudent   operator=(const CStudent &b)
    { 
        if (&b == this)
        {
            return *this;
        }
        if (NULL == b.m_pName)
        {
            delete []m_pName;
            m_pName = NULL;
            return *this;
        }
        delete []m_pName;
        int len=strlen(b.m_pName);
        m_pName=new char[len+1];
        memset(m_pName, 0, len+1);
        strcpy(m_pName,b.m_pName);
        return *this;
    }
#else
    //重载赋值函数  返回引用
    CStudent& operator=(const CStudent &b)
    {
        if (&b == this)
        {
            return *this;
        }
        if (NULL == b.m_pName)
        {
            delete []m_pName;
            m_pName = NULL;
            return *this;
        }
        delete []m_pName;
        int len = strlen(b.m_pName);
        m_pName = new char[len + 1];
        memset(m_pName, 0, len+1);
        strcpy(m_pName, b.m_pName);
        return *this;
    }
#endif
    //或者 我们也可以这样重载赋值运算符 即不返回任何值。如果这样的话，他将不支持客户代码中的链式赋值
    //例如a=b=c will be prohibited!
    //void operator=(const CStudent &a);

private:
    char *m_pName;
};



int main()
{
    {
        CStudent  liubei("liubei");
        CStudent  guanyu("guanyu");
        CStudent  zhangfei("zhangfei");
        //CStudent  dd(NULL);
        //CStudent  ff(dd);
        liubei = guanyu = zhangfei;
    } 
    system("pause"); 
    return 0;
}

运行结果：

这里为了说明问题，在拷贝构造函数中添加了类对象的处理，因此出现了上图结果中最后一行析构函数中出现了zhang_fei_copy_construct的结果。在实际中肯定不会这样做，因此实际在写代码中，返回引用和返回对象的结果都一样，但是由于返回对象的运算符重载函数多了拷贝构造函数的调用， 而且当运算顺序为（a=b）=c时，结果与预想的结果不同，因此建议使用运算符重载函数返回引用。

当把上述代码修改为时：

(liubei = guanyu) = zhangfei

运行结果为（为什么结果是这样的，由于 liubei = guanyu 先调用运算符重载函数得到结果，产生一个临时对象tem_c，然后调用拷贝构造函数tem_c(*this), *this是运算符重载函数的返回对象，同时tem_c = zhangfei调用了运算符重载函数，得到一个临时对象tem_a，然后调用拷贝构造函数tem_a(*this)，因此得到如下结果）：

2. 运算符重载函数返回类对象的引用

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

class CStudent
{
public:
    CStudent(char *pName) :m_pName(NULL)
    {
        if (NULL == pName)
        {
            return;
        }
        m_pName = new char[strlen(pName) + 1];
        strcpy(m_pName, pName);
        printf("CStudent: address:0x%08x name:%s\n", this, m_pName);
    }
    ~CStudent()
    {
        printf("~CStudent: address:0x%08x name:%s\n", this, m_pName);
        delete []m_pName;
    }
    //拷贝构造函数
    CStudent(const CStudent &a) :m_pName(NULL)
    {
        if (NULL == a.m_pName)
        {
			cout<<"reference"<<endl;
            return;
        }
        int len = strlen(a.m_pName);
        this->m_pName = new char[len + 20];
        memset(m_pName, 0, len + 20);
        strcpy(m_pName, a.m_pName);
        strcat(m_pName, "_copy_construct"); // 为了测试
        printf("copy construct: address:0x%08x name:%s\n", this, this->m_pName);
    }
public:
#if 0
    //重载赋值函数   返回对象
    CStudent   operator=(const CStudent &b)
    { 
        if (&b == this)
        {
            return *this;
        }
        if (NULL == b.m_pName)
        {
            delete []m_pName;
            m_pName = NULL;
            return *this;
        }
        delete []m_pName;
        int len=strlen(b.m_pName);
        m_pName=new char[len+1];
        memset(m_pName, 0, len+1);
        strcpy(m_pName,b.m_pName);
        return *this;
    }
#else
    //重载赋值函数  返回引用
    CStudent& operator=(const CStudent &b)
    {
        if (&b == this)
        {
            return *this;
        }
        if (NULL == b.m_pName)
        {
            delete []m_pName;
            m_pName = NULL;
            return *this;
        }
        delete []m_pName;
        int len = strlen(b.m_pName);
        m_pName = new char[len + 1];
        memset(m_pName, 0, len+1);
        strcpy(m_pName, b.m_pName);
        return *this;
    }
#endif
    //或者 我们也可以这样重载赋值运算符 即不返回任何值。如果这样的话，他将不支持客户代码中的链式赋值
    //例如a=b=c will be prohibited!
    //void operator=(const CStudent &a);

private:
    char *m_pName;
};



int main()
{
    {
        CStudent  liubei("liubei");
        CStudent  guanyu("guanyu");
        CStudent  zhangfei("zhangfei");
        //CStudent  dd(NULL);
        //CStudent  ff(dd);
        liubei = guanyu = zhangfei;
    } 
    system("pause"); 
    return 0;
}

运行结果：

当把上述代码修改为时：

(liubei = guanyu) = zhangfei

运行结果为（运行过程为： liubei = guanyu先调用运算符重载函数，由于返回的是liubei的引用，因此进行 liubei = zhangfei调用运算符重载函数）：

[Reference]

[1]代码参考：https://blog.csdn.net/miyunhong/article/details/51149376

holmes_MX
关注
C++ 连续赋值运算符重载，若没返回引用类型发生的错误
keke博客
03-05 1061
C++ 运算符重载返回引用类型 “=”、+=“”、“>>”、“<<”等运算符支持连续赋值或可作为左值的运算符，返回类型必须为引用类型。 问题描述： #include<iostream> using namespace std; class S { public : int x; S(int i) { x = i; } S operator = (S i) { x = i.x; return *this; } }; int main()
C++类的默认成员函数 —— 赋值重载
wihkum
11-27 1421
C++类的默认成员函数 —— 赋值重载
C++: 运算符重载
e.g.:
04-06 1359
C++中允许在同一作用域中的某个运算符指定多个定义。 通过重定义（重载）C++内置的运算符，使用自定义类型的运算符。 重载的运算符由关键字 operator 要重载的运算符符号构成的。重载运算符需要一个返回类型和一个参数列表。 //两个Box相加 Box operator+(const Box&); Box operator+(const Box&，const Box&); 可重载运算符列表： 运算符 符号 双目算术运算符 + (加)，-(减), (乘)，/(除)，
C++中的运算符重载
今天你学习了吗？
01-17 936
以下为本人大一时阅读《C++ Primer Plus》中关于运算符重载章节所做的笔记 string类的重载运算符： 函数empty判断string是否为空 函数substr返回现有string的一部分 s.substr(a,b)返回将字符串s从下标a处开始截取长度为b的字符串 函数at返回string中位于指定下标处的字符 不能被重载的运算符： * :: ?: 运算符重载的规则和限制： 重载二元运算符： 尽管可以重载运算符"&" "&&a...
【C++】运算符重载详解
qq_64818885的博客
02-04 5957
运算符重载函数的参数取决于要重载的运算符的操作数个数和类型。
C++运算符重载函数基础及其值返回状态
11-06 380
c++——运算符重载（四） 源码
09-09
对于赋值运算符（如"="），我们需要特别注意，因为它涉及到对象的赋值行为，通常应返回左操作数的引用，以支持连续赋值（如 `a = b = c`）。 此外，还有复合赋值运算符（如 "+="、"-=" 等），它们结合了赋值和某种...
c++特殊运算符重载---流运算符重载（csdn）————程序.pdf
12-01
在C++编程语言中，运算符重载是一种强大的特性，允许程序员为自定义类型赋予特定的行为，以便它们能像内置类型一样使用。本篇将详细探讨流运算符重载，也就是`和`>>`这两个运算符在处理输入输出流时如何被重载。 ...
C++知识整理day3类与对象（下）——赋值运算符重载、取地址重载、列表初始化、友元、匿名对象、static
qq_59702185的博客
12-03 1123
赋值运算符重载是六个默认成员函数之一，在讲解这个我们要先了解一下运算符重载。当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符的时候，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会报编译错误。注意：对于下面的例子中，都是使用的Date类。 运算符重载是具有特别名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，他也具有其返回类型和参数列表以及函数体。 重载运算符函数的参数个数和该运算符作⽤的运算对象
C++——类和对象3|日期类型|Cout运算符重载|Cin运算符重载|const成员|
weixin_49449676的博客
08-31 1340
Date*类型。
C++自定义类重载‘=’运算符
weixin_45805339的博客
08-05 564
在 C++ 中，自定义类可以使用“=”赋值运算符进行赋值，但只有在为该运算符提供了定义的情况下。在默认情况下，C++ 提供了一个默认的赋值运算符，该运算符执行逐位拷贝（bitwise copy），适用于简单的数据类型和对象。然而，如果你的类包含指针或动态分配的资源（如字符串、数组等），那么默认的赋值可能导致资源管理出现问题，例如内存泄漏或双重释放。为此，你应该显式地重载赋值运算符，以管理资源的正确复制。
C++中有些运算符重载为什么要返回引用
weixin_45997515的博客
09-23 849
str3只得到了str1的内容，并没有得到str2的内容，这是因为执行(str3=str1)后，因为返回的是对象（一个临时对象，str3的一个拷贝），不是引用，所以此时str3不在后面的‘=str2’的操作中，而是str2对一个临时对象赋值，所以str3的内容保持不变（等于str1）。需要返回对象引用或者返回对象（效率没有返回引用高），需要实现连续赋值，使重载的运算符更符合C++本身的运算符语意，如连续赋值 = += -= *= 、=，<<输出流。//运算符重载，此时返回的是对象。
【C++】详解运算符重载，赋值运算符重载，++运算符重载
2301_79796701的博客
04-18 2657
狂敲键盘，只为博君一笑
C++：运算符重载
陈小默的博客
09-05 3164
C++：运算符重载标签（空格分隔）： c++ 作者：陈小默C运算符重载 运算符重载规则 自定义时间运算 重载运算符的两种使用方式 多个重载运算符的连续运算 重载限制 当我们学习C++的时候，一定接触过cout对象，你一定好奇过为什么左移运算符在这里就成了插入运算符了呢？所以这一节我们就来介绍一下吊炸天的C++运算符重载机制。运算符重载规则operatorOP(argument-list)重载运算符
自定义类，运算符重载
skyangnan的博客
12-07 223
运算符重载
【C++面向对象】自定义重载操作符
Hyman的博客
11-02 1854
什么是自定义重载操作符？我们知道C++允许我们对+、++、=等操作符进行重载，而我们在进行重载时，往往都会根据使用习惯，赋予它的近似原来的表现和行为。 比如++运算符，在我们的概念中就是本事自加1，而我们在类中重载时往往也会这么做。本文研究的是将这些运算符重载成自定义的行为，以++为例，我们将其重载为计算一个类的平方。这种方式在实际编程中很少用到，本文主要通过这种方式介绍用算符重载时的两个规则：
C++ 语言赋值运算符 - 连续赋值
程永强
02-19 5277
C++ 语言赋值运算符 - 连续赋值 赋值运算符的左侧运算对象必须是一个可修改的左值。 int i = 0, j = 0, k = 0; // 初始化而非赋值 const int len = i; // 初始化而非赋值 下面的赋值语句都是非法的： 1024 = k; // 错误：字面值是右值 i + j = k; // 错误：算术表达式是右值 len = k; // 错误：len 是常量 (不可修改) 左值 赋值运算的结果是它的左侧运算对象，并且是一个左值，结果的类型是左侧运算对象
C++自定义类在进行计算时常常遇到“==”的重载
weixin_36212725的博客
03-17 419
关于C++自定义类“==”的重载，如下： Class Code { public: int left; int right; int bottom; int top; bool opearator==(Code& rhs) con...
C++重载操作符
hhhcbw的博客，欢迎各位来访
07-29 870
普通函数的实参则在函数名之后的圆括号中列出。除了写法上的区别，作为类的成员，其只能位于第一个参数的位置（作为调用对象），比如下面的一个例子。无论是作为类的成员还是友元函数都是合法的。这里需要重点说明的是，将操作符函数作为类的成员与友元函数的区别。我们可以按照下面的方式定义一个获取一个整型的构造函数。代码看起来简单和自然，但存在一个问题，就是我们之前的代码没有重载对象与整型之间的。如果类定义包含了恰当的构造函数，系统会自动执行特定的类型转换。而下面的例子，如果作为类的成员就是不合法的，而作为友元函数则合法。.
拷贝构造运算符重载和赋值操作符重载
最新发布
12-29
### C++ 中拷贝构造函数与赋值操作符重载的区别 #### 拷贝构造函数 当创建一个新的对象并初始化它为另一个同类型对象的时候，会调用拷贝构造函数。如果类中没有显式定义拷贝构造函数，则编译器提供默认版本[^4]。 对于自定义资源管理（比如动态分配内存），通常需要编写自己的拷贝构造函数来执行深拷贝而不是简单的位复制（即浅拷贝）。这可以防止多个对象共享同一块堆内存放的数据而导致潜在的风险和错误。 ```cpp class MyClass { public: int* data; // 构造函数 MyClass(int value) : data(new int(value)) {} // 拷贝构造函数 MyClass(const MyClass& other) : data(new int(*other.data)) {} // 执行深拷贝 ~MyClass() { delete data; } }; ``` #### 赋值操作符重载 而赋值操作符用于已经存在的对象之间相互赋值的情况。同样地，默认情况下编译器提供了基本功能；但是为了处理复杂情况下的正确性和效率问题，可能也需要手动实现这个过程——特别是涉及到动态内存或其他形式外部资源的情况下： - 需要释放当前持有的资源； - 复制源对象的内容到目标对象上； - 返回`*this`以便支持链式表达式的使用方式。 ```cpp class MyClass { public: int* data; // ...其他成员... // 赋值操作符重载 MyClass& operator=(const MyClass& rhs) { if (this != &rhs) { // 自我赋值检查 *data = *(rhs.data); // 进行必要的清理工作以及新数据的复制 } return *this; // 支持连续赋值语句 } private: }; ``` #### 主要区别 1. **生命周期阶段不同** - 拷贝构造发生在对象创建之时。 - 赋值则是在两个已有的对象间交换状态之后发生。 2. **作用域差异** - 前者仅限于构造期间有效。 - 对于赋值来说非常重要，因为可能存在同一个对象给自己赋值的情形。 - 拷贝构造不存在这种情况，因为它总是在构建全新的实例时触发。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值