首页 > 编程语言 >从C向C++——运算符重载

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

时间：2024-01-31 13:02:08浏览次数：24  
标签：函数 int age C++ 运算符 Person 重载

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

1.运算符重载

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

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

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

首先，如果是两个常见的变量比如int a=10和int 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;
}

我们在这个例子中实例化了两个对象p1和p2，假设我现在要实例化一个对象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++ 内置的数据类型（例如 bool、int、double 等）和标准库所包含的类类型（例如 string、complex、ofstream、ifstream 等）。

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

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

cout<<per1<<per2<<endl;

输入形式就是：

cin>>per1>>per2;

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

所以：<<和>>的重载只能以全局函数（友元函数）的形式重载。

#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;
}

这里想要说明的是，虽然平时我们经常使用cin和cout，但很多不知道其到底是什么，其实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上运行的，但是你仔细看看有没有什么需要修改的地方，我们知道new和delete关键字成对出现，现在我在构造函数里使用了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;
}

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

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

结合原理图来理解，执行完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中被重载，才成为所谓的“流插入运算符”和“流提取运算符”的。

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

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

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

标签：函数,int,age,C++,运算符,Person,重载
From： https://blog.51cto.com/u_16150223/9507794

相关文章

  • 《C++ Primer Plus》（第六版）中文版——思维导图+附录PDF+源代码
    说明，以下文件可在异步社区免费下载不同之处在于原附录PDF文件没有书签，而本文分享的附录文件带有书签本文所有文件下载链接：https://www.123pan.com/s/lO3uVv-uaEKv.html思维导图（图片）以下仅为预览，高清图片可从文章开头下载链接中下载另外后续本人有空会制作XMind脑图版本，会添加......
  • 【侯捷C++面向对象笔记】补充5-new & delete重载
    平时所使用的new和delete操作，称之为表达式，一般由好几个步骤组成。如上图所示，new表达式会被编译器转化为三个步骤。new表达式不能重载，但其中operatornew是可以重载的。➡️全局::operatornew的重载why不能放在namespace内？因为全局operatornew是放在defaultglobalnamespac......
  • C#中问号（?）运算符的历代新增用法
    本文是B站up主十月的寒流的相应视频的学习笔记，可以直接访问该视频获取更详细的讲解：C#中问号（?）运算符的历代新增用法C#1.0三目运算符stringres=x>5?"goood":"no"C#2.0可为空的值类型(NullableValueTypes)int?x=null;上述代码本质上是Nullable<int>x=nul......
  • 【侯捷C++面向对象笔记】补充2-pointer-like & function-like class
    关键词：仿函数pointer-like：将一个类设计得像指针一样，通常通过重载*和->操作符实现。function-like：将类的成员设计得能像函数一样使用，通过重载()操作符实现。TipDemo应用：智能指针注意：->符号在作用一次后，会继续作用下去（不同于*号）Foof(*sp)：f为一个Foo对象本体，使用时f.m......
  • 【侯捷C++面向对象笔记】补充3-template
    关键词：类模板，函数模板，成员模板，模板特化“泛化”和“特化”TipDemo类模板定义时需要显式地指定类型名。函数模板定义时编译器自动进行实参推导类型（但不提供隐式转换）。成员模板：模板中还包含模板模板（全）特化格式：template<>尖括号内为空模板偏特化(partia......
  • 【侯捷C++面向对象笔记】补充4-object model
    关键词：虚函数表，动态绑定，多态每个对象都维护自己的虚表指针，指向类的虚函数表。（所以对象的size比其包含的所有数据size多4，即虚指针大小）➡️动态绑定：（多态的实现原理）通过指针p找到对象c的vptr通过vptr找到classC的vtbl在vtbl中找到第n个虚函数并调用➡️子类调用父类函数隐......
  • 【侯捷C++面向对象笔记】String类
    关键词：动态内存分配，拷贝赋值，new/delete与Complex类最大的差别：有动态分配的内存空间（char*m_data）TipDemo拷贝赋值函数的一般结构拷贝赋值时，检测自我赋值非常重要自己的内存已经释放了，还怎么把自己赋给自己？new时做了什么？1.分配内存2.static_cast为相应类型指针......
  • KY146 魔咒词典C++
    构建一个map，还是查找问题。麻烦点就是要分解输入的过程#include<iostream>#include<string>#include<map>usingnamespacestd;intmain(){stringa,b;map<string,string>m;while(getline(cin,a)){//构建mapb.clear();if(a[0]==......
  • KY27 查找学生信息C++
    用map做查找就行了。#include<iostream>#include<string>#include<map>usingnamespacestd;structnode{stringname;stringx;intage;};typedefstructnodesinfo;intmain(){intn;while(cin>>n){map<......
  • c++ - 实现环形队列
    简介队列的核心思想是FIFO(FirstInFirstOut)，即先入先出。入队（新增元素）必须从队尾加入，出队（删除元素）必须从队首出去。实现1、需要实现的方法#pragmaonce#include<iostream>usingnamespacestd;#ifndefMYQUEUE_H#defineMYQUEUE_H//环形队列的实现classMyQueue{......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99