从C向C++6——运算符重载

本文的主要知识点是C++中的运算符重载。

1.运算符重载

所谓重载,就是赋予新的含义。函数重载(Function Overloading)可以让一个函数名有多种功能,在不同情况下进行不同的操作。**运算符重载(Operator Overloading)**也是一个道理,同一个运算符可以有不同的功能。

实际上,我们已经在不知不觉中使用了运算符重载。例如,+号可以对不同类型(int、float 等)的数据进行加法操作;<<既是位移运算符,又可以配合 cout 向控制台输出数据。C++本身已经对这些运算符进行了重载。C++ 也允许程序员自己重载运算符,这给我们带来了很大的便利。

谈谈我的个人理解来帮助理解运算符重载:

​ 首先,如果是两个常见的变量比如int a=10int b=5,我们可以进行加法操作int c=a+b,这个编译器是可以理解的,但是如果我现在定义一个类:

class Person{
public:
    int m_a;
    int m_b;
    
}


int main(){
    Person p1,p2;
    p1.m_a=10;
    p1.m_b=10;
    p2.m_a=5;
    p2.m_b=5;
}

我们在这个例子中实例化了两个对象p1p2,假设我现在要实例化一个对象p3,其属性的赋值是

p3.m_a=p1.m_a+p2.m_a;
p3.m_b=p1.m_a+p2.m_b;

但是这样太复杂了,如果美创建一个对象都是怎么做的话,太复杂了,自然而然的我们想到定义一个函数去解决这类问题。这里可以采用成员函数也可以使用全局函数来解决问题,但C++中一般更喜欢成员函数。

class Person{
public:
    int m_a;
    int m_b;
    Person personadd(Person &p);
    
}

Person Person::personadd(Person &p){
    Person temp;
    temp.m_a=this->m_a+p.m_a;
    temp.m_b=this->m_b+p.m_b;
}

int main(){
    Person p1,p2;
    p1.m_a=10;
    p1.m_b=10;
    p2.m_a=5;
    p2.m_b=5;
    Person p3=p1.personadd(p2);//????????????????
}

经过 我们写的一个成员函数后,是不是就可以利用上面的代码建立p3对象啦,比原来的慢慢赋值方便多了,那么假设现在编译器规定了函数名只能叫operator+,那么我们是不是要变成这样使用:

class Person{
public:
    int m_a;
    int m_b;
    Person operator+(Person &p);
    
}

Person Person::operator+(Person &p){
    Person temp;
    temp.m_a=this->m_a+p.m_a;
    temp.m_b=this->m_b+p.m_b;
}

int main(){
    Person p1,p2;
    p1.m_a=10;
    p1.m_b=10;
    p2.m_a=5;
    p2.m_b=5;
    Person p3=p1.operator+(p2);//????????????????
}

其实这就是对+号进行了重载,定义p3的代码可以写成Person p3=p1+p2,所以我们这里运算符重载的本事就是一个函数的重载而已,对运算符重载实质了解之后,再来学习运算符的重载。

注意:本部分的代码未在编译器测试,不具有运行效果,单纯是为了方便理解。

2.重载’+’

#include <iostream>
using namespace std;
class complex{
public:
    complex();
    complex(double real, double imag);
public:
    //声明运算符重载
    complex operator+(const complex &A) const;
    void display() const;
private:
    double m_real;  //实部
    double m_imag;  //虚部
};
complex::complex(): m_real(0.0), m_imag(0.0){ }
complex::complex(double real, double imag): m_real(real), m_imag(imag){ }
//实现运算符重载
complex complex::operator+(const complex &A) const{
    complex B;
    B.m_real = this->m_real + A.m_real;
    B.m_imag = this->m_imag + A.m_imag;
    return B;
}
void complex::display() const{
    cout<<m_real<<" + "<<m_imag<<"i"<<endl;
}
int main(){
    complex c1(4.3, 5.8);
    complex c2(2.4, 3.7);
    complex c3;
    c3 = c1 + c2;
    c3.display();
    return 0;
}

本例中义了一个复数类 complex,m_real 表示实部,m_imag 表示虚部,第 10 行声明了运算符重载,第 21 行进行了实现(定义)。认真观察这两行代码,可以发现运算符重载的形式与函数非常类似。

运算符重载其实就是定义一个函数,在函数体内实现想要的功能,当用到该运算符时,编译器会自动调用这个函数。也就是说,运算符重载是通过函数实现的,它本质上是函数重载。

3.运算符重载规则

运算符重载是通过函数重载实现的,概念上大家都很容易理解,这节我们来说一下运算符重载的注意事项。

  1. 并不是所有的运算符都可以重载。能够重载的运算符包括:
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |=  << >> <<= >>= == != <= >= && || ++ -- , ->* -> () []  new new[] delete delete[]

上述运算符中,[]是下标运算符,()是函数调用运算符。自增自减运算符的前置和后置形式都可以重载。

长度运算符sizeof、条件运算符: ?、成员选择符.和域解析运算符::不能被重载。

  1. 重载不能改变运算符的优先级和结合性。假设上一节的 complex 类中重载了+号和*号,并且c1、c2、c3、c4都是 complex 类的对象,那么下面的语句c4 = c1 + c2 * c3;等价于c4 = c1 + ( c2 * c3 );,乘法的优先级仍然高于加法,并且它们仍然是二元运算符。

  2. 重载不会改变运算符的用法,原有有几个操作数、操作数在左边还是在右边,这些都不会改变。例如~号右边只有一个操作数,+号总是出现在两个操作数之间,重载后也必须如此。

  3. 运算符重载函数不能有默认的参数,否则就改变了运算符操作数的个数,这显然是错误的。

  4. 运算符重载函数既可以作为类的成员函数,也可以作为全局函数。

  5. 箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。

将运算符重载函数作为类的成员函数时,二元运算符的参数只有一个,一元运算符不需要参数。之所以少一个参数,是因为这个参数是调用成员函数时隐含的。另外,将运算符重载函数作为全局函数时,一般都需要在类中将该函数声明为友元函数。原因很简单,该函数大部分情况下都需要使用类的 private 成员。

4.重载<<和>>

在C++中,标准库本身已经对左移运算符<<和右移运算符>>分别进行了重载,使其能够用于不同数据的输入输出,但是输入输出的对象只能是 C++ 内置的数据类型(例如 boolintdouble 等)和标准库所包含的类类型(例如 stringcomplexofstreamifstream 等)。

如果我们自己定义了一种新的数据类型,需要用输入输出运算符去处理,那么就必须对它们进行重载。

要达到的目标是让自定义类的输入输出和 int、float 等基本类型一样简单。假设 per1per2Person类实例对象,那么输出形式就是:

cout<<per1<<per2<<endl;

输入形式就是:

cin>>per1>>per2;

cout ostream 类的对象,cinistream 类的对象,要想达到这个目标,就必须以全局函数(友元函数)的形式重载<<>>,否则就要修改标准库中的类,这显然不是我们所期望的。

所以:<<>>的重载只能以全局函数(友元函数)的形式重载。

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

class Person {
    friend ostream& operator <<(ostream& out, Person& A);
public:
    Person(int a, int b) :m_a(a), m_b(b) {};
private:
    int m_a;
    int m_b;

};

ostream& operator <<(ostream& out, Person& A) {
    out << "Ad的m_a为:"<<A.m_a << " A的m_b为: "<<A.m_b<<endl;
    return out;
}

void test01() {
    Person p(10,10);
    cout << p << endl;
}

int main() {
    test01();

    return 0;
}

这里想要说明的是,虽然平时我们经常使用cincout,但很多不知道其到底是什么,其实cin是一个输入流类istream的实例化对象,而cout其实是输出流类ostream的一个实例化对象。

5.重载自增运算符

自增++和自减--都是一元运算符,它的前置形式和后置形式都可以被重载。

#include<iostream>
using namespace std;


class Myint {
    friend ostream& operator <<(ostream& out, Myint myint);
private:
    int m_num;
public:
    Myint(){
        m_num = 0;
    };
    //重载前置++
    Myint& operator++() {
        m_num++;
        return *this;
    }
    //重载后置++,这里使用到占位参数
    Myint operator++(int) {
        Myint temp = *this; //记录当前值
        m_num++;       //再加1
        return temp; //返回的是局部变量,不能返回局部变量的引用
    }

};

//重载<<
ostream& operator <<(ostream& out, Myint myint) {
    out << "我的数据为: "<<myint.m_num<<endl;
    return out;
}

void test01() {
    Myint myint;
    cout <<++ (++myint) << endl;
    cout << myint++ << endl;
    cout << myint << endl;
}

int main() {
    test01();

    return 0;
}

注意:

  • 如何区分前置++和后置++的重载------------->使用占位参数
  • 前置++返回引用,后置++返回值

6.重载赋值运算符

c++编译器至少给一个类添加4个函数

  • 1.默认构造函数(无参,函数体为空)
  • 2.默认析构函数(无参,函数体为空)
  • 3.默认拷贝构造函数,对属性进行值拷贝
  • 4.赋值运算符 operator=,对属性进行值拷贝

看过之前的文章可能知道之前写的添加只有3个,第四个是今天的重点内容,在后面模板中也会用到。

请看下面代码:

#include<iostream>
using namespace std;


class Person {
public:
    int* m_age;
    Person(int age) {
        m_age = new int(age);    //创建在堆区
    }
};

void test01() {
    Person p1(18);
    cout << *p1.m_age << endl;
    Person p2(20);
    cout << *p2.m_age << endl;
    p2 = p1;                  //重点代码
}

int main() {
    test01();

    return 0;
}

该部分代码是可以在VSCode上运行的,但是你仔细看看有没有什么需要修改的地方,我们知道newdelete关键字成对出现,现在我在构造函数里使用了new,那么同理要在析构函数里释放其空间,所以有:

#include<iostream>
using namespace std;


class Person {
public:
    int* m_age;
    Person(int age) {
        m_age = new int(age);    //创建在堆区
    }
    ~Person() {
        if (m_age != NULL) {
            delete m_age;
            m_age = NULL;
        }
    }
};

void test01() {
    Person p1(18);
    cout << *p1.m_age << endl;
    Person p2(20);
    cout << *p2.m_age << endl;
    p2 = p1;                  //重点代码
}

int main() {
    test01();

    return 0;
}

这段代码会出错,为什么呢?其实这在之前的拷贝构造函数那里已经说过一次啦,浅拷贝带来的问题我们叫内存空间重复释放,可以使用深拷贝来解决。

在这里插入图片描述

结合原理图来理解,执行完p1的析构函数后存18的内存空间已经释放,而再执p2的析构函数时就会重复释放内存空间导致程序崩溃,之前是通过拷贝构造函数产生的这类问题,现在是直接通过赋值运算符=产生的这类问题,其实你仔细思考以下,对象的赋值在某种程度上不就是一种浅拷贝吗?

好的理解玩这些,我们知道解决问题的方法就是使用深拷贝,那么现在把赋值运算符进行重载,用神拷贝的思想解决问题。

#include<iostream>
using namespace std;


class Person {
public:
    int* m_age;

    Person(int age) {
        m_age = new int(age);    //创建在堆区
    }
    ~Person() {
        if (m_age != NULL) {
            delete m_age;
            m_age = NULL;
        }
    }


    //重载赋值运算符
    Person& operator=(Person& p) {
        //编译器提供的赋值是浅拷贝

        //应该先判断是否有属性在堆区,如果有释放干净
        if (m_age != NULL) {
            delete m_age;
            m_age = NULL;
        }

        //深拷贝
        m_age = new int(*p.m_age);

        return *this;
    }
};

void test01() {
    Person p1(18);
    cout << *p1.m_age << endl;
    Person p2(20);
    p2 = p1;                  //重点代码
    cout << *p2.m_age << endl;
}

int main() {
    test01();

    return 0;
}

7.重载函数调用运算符

  • 函数调用运算符()也可以重载
  • 由于重载后使用的方式非常像函数的调用,因此称为仿函数
  • 仿函数没有固定写法,非常灵活

本部分需要知道一点:仿函数是什么?仿函数就是对函数调用运算符()进行了重载,注意根据前面重载规则我们知道()只能以成员函数重载。

#include<iostream>
using namespace std;


class Myadd {
public:
    int operator()(int num1, int num2) {
        return num1 + num2;
    }

};

void test01() {
    Myadd myadd;
    int ret = myadd(10, 10);
    cout << "ret= " << ret << endl;
}

int main() {
    test01();

    return 0;
}

我们看到了通过在Myadd类中的运算符重载,能够实现我们以往函数的功能,所以把对()的重载也成为仿函数。

8.C++运算符重载汇总

在 C++中进行运算符重载时,有以下问题需要注意:

  • 重载后运算符的含义应该符合原有用法习惯。例如重载+运算符,完成的功能就应该类似于做加法,在重载的+运算符中做减法是不合适的。此外,重载应尽量保留运算符原有的特性。
  • C++ 规定,运算符重载不改变运算符的优先级。
  • 以下运算符不能被重载:..*::? :sizeof
  • 重载运算符()[]->、或者赋值运算符=时,只能将它们重载为成员函数,不能重载为全局函数。

运算符重载的实质是将运算符重载为一个函数,使用运算符的表达式就被解释为对重载函数的调用。

运算符可以重载为全局函数。此时函数的参数个数就是运算符的操作数个数,运算符的操作数就成为函数的实参。

运算符也可以重载为成员函数。此时函数的参数个数就是运算符的操作数个数减一,运算符的操作数有一个成为函数作用的对象,其余的成为函数的实参。

必要时需要重载赋值运算符=,以避免两个对象内部的指针指向同一片存储空间。

运算符可以重载为全局函数,然后声明为类的友元。

<<和>>是在iostream中被重载,才成为所谓的“流插入运算符”和“流提取运算符”的。

类型的名字可以作为强制类型转换运算符,也可以被重载为类的成员函数。它能使得对象被自动转换为某种类型。

自增、自减运算符各有两种重载方式,用于区别前置用法和后置用法。

运算符重载不改变运算符的优先级。重载运算符时,应该尽量保留运算符原本的特性。

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>