编程语言
首页 > 编程语言> > C++的运算符重载(2)

C++的运算符重载(2)

作者:互联网

目录

一、赋值运算符重载函数返回引用

1、返回引用好处1:提升程序效率

(1)赋值运算符重载函数返回值可以返回对象类型,也可以返回对象引用类型,都能工作。代码验证

#include <iostream>

using namespace std;

class coordinate
{
public:
    int x, y;

    void print(void);
    //coordinate& operator=(const coordinate& other);
    coordinate operator=(const coordinate& other);
    coordinate();
    coordinate(int x0, int y0);
    coordinate(const coordinate& rhs);    
};

void coordinate::print(void)
{
    cout << "a=(" << this->x << "," << this->y << ")" << endl;
}

#if 0
coordinate& coordinate::operator=(const coordinate& other)
{
    this->x = other.x;
    this->y = other.y;

    return *this;
}
#else
coordinate coordinate::operator=(const coordinate& other)
{
    this->x = other.x;
    this->y = other.y;

    return *this;
}

#endif

coordinate::coordinate()//默认构造函数
{
    this->x = 0;
    this->y = 0;
}

coordinate::coordinate(int x0, int y0)//自定义构造函数
{
    cout << "------constructor-------" << endl;

    this->x = x0;
    this->y = y0;
}

coordinate::coordinate(const coordinate& rhs)//拷贝构造函数
{
    cout << "------copy_constructor-------" << endl;

    this->x = rhs.x;
    this->y = rhs.y;
}

int main(int argc, char *argv[])
{
    coordinate a(1,5);
    coordinate b(4,5);
    coordinate c;

    cout << "----------c = a---------" <<endl;
    c = a;
    cout << "----------c = a---------" <<endl;

    a.print();
    b.print();
    c.print();

    return 0;
}

在这里插入图片描述
  图中上边的部分是返回引用的打印信息,下边的是返回对象的打印信息,返回对象时调用了拷贝构造函数。

(2)区别在于:返回引用可以避免一次返回值值传递的对象复制,这需要消耗资源的。

(3)总结:虽然C++语法并未强制要求,但是好的写法是应该返回引用

2、返回引用好处2:允许连续赋值式

(1)返回对象而不是引用时,在连续赋值(c = a = b;)时会编译可以,运行也可以,但是效率低同1中所讲。

(2)原因是先执行a=b操作,返回值再作为第2次赋值运算的右值(也就是函数参数),对象和引用是类型兼容的

(3)总结:连等在返回对象和引用时都可以,但是在返回void时就不可以了

3、思考:传参为什么要传引用

(1)如果传对象,则调用时是值传递,调用时需要复制一次,增加额外开销

(2)如果传指针,则重载后,使用时为了符合函数参数格式必须写成 a = &b;这种,不符合C语言写法习惯,也有歧义

(3)实际测试发现真的传指针时,写 c=a; c=&a;都能编译通过,且运行正确。但是确实很别扭。

(4)总结:有资料表明,其实C++早期发明引用概念时,就是为了解决此处运算符重载传参的尴尬。

二、String类的赋值运算符重载

1、标准库中String类的运算符重载

(1)https://zh.cppreference.com/w/%E9%A6%96%E9%A1%B5

(2)String类提供了 = 和 + 等多个运算符重载函数的成员

(3)标准库只给了API,没给实现,咱们可以自己实现个=运算符重载函数

2、String的=运算符重载演练

(1)自己编写一个MyString类,成员变量char *buf指向实际存储字符串的buf,new动态内存来使用。
(2)实践:先完成构造函数,成员函数print,len等基础设计,写代码测试ok
(3)编写=运算符重载函数,引出浅拷贝深拷贝问题

#include <iostream>

using namespace std;

class Mystring
{
private:
    char *buf; //指针指向实际存储字符串内容的buffer空间,采用动态分配

public:
    int len;   //字符中存储的有效字符个数

    Mystring();                //构造函数
    Mystring(const char *pSrc);      //拷贝构造函数
    ~Mystring();               //析构函数
    void print(void);          //普通成员函数
    Mystring& operator=(const Mystring& other);//运算符重载函数
};

Mystring::Mystring()
{
    //不写,空着等需要时再写,因为提供了自定义的构造函数,
    //所以必须要由默认的构造函数
    this->len = 32;
    this->buf = new char[32];
}

Mystring::Mystring(const char *pSrc)
{
    //计算有效字符的个数
    const char *p = pSrc;
 
    this->len = 0;
    while(*p++ != '\0')
    {
        this->len++;
    }
    cout << "cnt of pSrc is " << this->len << endl;

    //先给buf分配动态内存空间
    this->buf = new char[this->len+1];

    //将pSrc指向的源字符串内容,复制给当前Mystring对象来存储
    p = pSrc;
    char *tmp = this->buf;
    while(*p != '\0')
    {
        *tmp++ = *p++;            
    }
    *tmp = '\0';
}

Mystring::~Mystring()
{
    delete[] this->buf;
}

void Mystring::print(void)
{
    cout << "length of string = " << this->len << endl;
    
    char *p = this->buf;

    cout << "this string is : ";
    while(*p != '\0')
    {
        cout << *p++;
    }
    cout << endl;
}

Mystring& Mystring::operator=(const Mystring& other)
{
    delete[] this->buf;//释放掉原来的内存,重新申请内存
    this->buf = new char[other.len+1];//避免字符串内存越界
    this->len = other.len;

    char *p1 = this->buf;
    char *p2 = other.buf;

    while(*p2 != '\0')
    {
        *p1++ = *p2++;
    }

    //return *this;
}

int main(int argc, char *argv[])
{
    Mystring s1("123456");
    Mystring s2("absjhlllbsb");

    s1.print();
    s2.print();

    cout << "-----------------------" << endl; 
    s1 = s2;

    s1.print();
    s2.print();

    return 0;
}

3、总结

(1)运算符重载技术本身很简单,就是个语法糖,前面讲的完全够了

(2)运算符重载会牵出其他技术点(譬如浅拷贝深拷贝)共同完成某个工作,这就有难点,讲究功底了

(3)C++编程中涉及到动态内存的地方一定要慎重,三思五思再慎重都不为过,运算符重载函数返回值类型不是引用而是对象可能会引发段错误,我上面提供的程序就会,调试了半小时才发现(我太菜了)。

三、++和–运算符的前置后置如何实现

1、可前置可后置的运算符

(1)int a = 5; a++; ++a;结果不同

(2)重载++和–有无意义
  有意义,因为我们有时习惯了C语言的++和–的便利性。

2、如何重载++和–

C++编译器认为:

a++; 对应Type& operator++(int x); //int x用来做区分,此外没有任何其他作用。

++a对应Type& operator++(void);

示例代码:https://www.runoob.com/cplusplus/increment-decrement-operators-overloading.html

3、总结

(1)即使你觉得没必要,但是也得会,因为总有人会这样写

(2)掌握最本质的规律的人最强大,遇到越困难的问题越需要这种能力来解决

四、两种运算符重载方法

1、并非所有运算符都支持重载

(1)下面是不可重载的运算符列表

.			成员访问运算符
.*, ->*		成员指针访问运算符
::			域运算符
sizeof		长度运算符
? :			条件运算符 
#           预处理符号

2、并非只有一种方式实现重载

(1)有两种方法可以使运算符重载
  第一种:使重载运算符成为该类的成员函数。这允许运算符函数访问类的私有成员。它也允许函数使用隐式的this指针形参来访问调用对象。

  第二种:使重载的成员函数成为独立分开的函数。当以这种方式重载时,运算符函数必须声明为类的友元才能访问类的私有成员。

3、如何选择两种运算符重载

(1)大多数运算符(如+ =等)既可以作为成员函数也可以作为独立函数重载。

(2)更好的做法是将二元运算符重载为釆用相同类型形参的独立函数。这是因为,与独立运算符的重载不同,成员函数的重载通过使左侧形参变成隐式的,造成了两个形参之间的人为区别,这将允许转换构造函数应用右侧形参,但不应用左侧形参,从而产生了更改形参顺序的情况,导致正确的程序如果换个方式却出现了编译器错误。

示例如下:
Length a(4, 2), c(0);
c = a + 2; //编译,当于 c = a.operator+(2)
c = 2 + a; //不能编译:相当于 c = 2.operator+(a);
参考学习:https://blog.csdn.net/jacket_/article/details/89714947

注:本文章参考了《朱老师物联网大讲堂》课程笔记,并结合了自己的实际开发经历以及网上他人的技术文章,综合整理得到。如有侵权,联系删除!水平有限,欢迎各位在评论区交流。

标签:++,C++,运算符,coordinate,int,重载,Mystring
来源: https://blog.csdn.net/weixin_45842280/article/details/122090732