26 CPP运算符重载

最新推荐文章于 2024-04-26 11:33:08 发布
最新推荐文章于 2024-04-26 11:33:08 发布
阅读量746 收藏
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wade1010/article/details/128367374
版权

 

 

#include <iostream>

using namespace std;

//非成员函数重载+ -
class Person {
public:
    Person() {
        m_score = 0;
        m_name.clear();
    }

    void show() {
        cout << m_name << " " << m_score << endl;
    }

    int m_score;
    string m_name;
};

//全局重载+号
void operator+(Person &p, int score) {
    p.m_score += score;
}

//全局重载-号
Person &operator-(Person &p, int score) {
    p.m_score -= score;
    return p;
}

void test() {
    Person p;
    p.m_score = 1;
    p + 10;
    p.show();
    p = p - 1 - 2;//同下
//    p = operator-(operator-(p, 1), 2);
    p.show();
}

int main() {
    test();
    return 0;
}
 11
 8
#include <iostream>

using namespace std;

//非成员函数重载+ -
class Person {
public:
    Person() {
        m_score = 0;
        m_name.clear();
    }

    void show() {
        cout << m_name << " " << m_score << endl;
    }

    void operator+(int score) {
        this->m_score += score;
    }

    Person &operator-(int score) {
        this->m_score -= score;
        return *this;
    }

    int m_score;
    string m_name;
};


void test() {
    Person p;
    p.m_score = 1;
    p + 10;
    p.show();
    p = p - 1 - 2;//同下
//    p = operator-(operator-(p, 1), 2);
    p.show();
}

int main() {
    test();
    return 0;
}

注意事项：

1 返回自定义数据类型的引用可以让多个运算符表达式串联起来。（不要返回局部变量的引用）

2 重载函数参数列表中顺序决定了操作数的位置（后面有代码说明）

3 重载函数的参数列表中至少有一个是用户自定义的类型，防止程序员为内置数据类型重载运算符

4 如果运算符重载既可以是成员函数也可以是全局函数，应该优先考虑成员函数，这样更符合运算符重载的初衷。

5 重载函数不能违背运算符原来的含义和优先级。（语法上没有限制不能这么做，但是这么做很垃圾）

6 不能创建新的运算符

7 以下运算符不可以重载

 

 8 以下运算符只能通过成员函数进行重载

 

 重载函数参数列表中顺序决定了操作数的位置 代码说明

#include <iostream>

using namespace std;

//重载函数参数列表中顺序决定了操作数的位置
class Person {
public:
    Person() {
        m_score = 0;
        m_name.clear();
    }

    void show() {
        cout << m_name << " " << m_score << endl;
    }

    int m_score;
    string m_name;
};

Person &operator+(Person &p, int score) {
    p.m_score += score;
    return p;
}

Person &operator+(int score, Person &p) {
    p.m_score += score;
    return p;
}

Person &operator+(Person &p1, Person &p2) {
    p1.m_score += p2.m_score;
    return p1;
}


void test() {
    Person p;
    p.m_score = 1;
    p + 10;
    p.show();
    //如上，重载的时候 Person &p, int score 顺序是这样，那么下面代码将报错
    p + 10 + p;//Invalid operands to binary expression ('void' and 'Person'
    //所以需要再写两个重载，顺序是int score,Person &p和Person &p1, Person &p2
    p.show();
}

int main() {
    test();
    return 0;
}

 

上图 关系运算符和左移运算符重载比较简单，其它几个运算符重载都有一些不一样的地方，C++编译器需要特别的处理。

重载左移运算符

#include <iostream>

using namespace std;

//左移运算符 cout
class People {
    friend ostream &operator<<(ostream &cout, const People &p);

    int m_age;
    int m_score;
public:
    People() {
        m_age = 18;
        m_score = 0;
    }

    ostream &operator<<(ostream &cout) {
        cout << m_age << " " << m_score << endl;
        return cout;
    }
};

ostream &operator<<(ostream &cout, const People &p) {
    cout << p.m_age << " " << p.m_score << endl;
    return cout;
}

void test() {
    People p;
    cout << p << endl;
    p << cout << endl;//如果是成员函数的重载，位置就不对了。
}

int main() {
    test();
    return 0;
}

重载下标运算符

 

 

 

 

 

注意：

1 编译器提供的默认赋值函数，是浅拷贝

2 如果对象不存在堆区内存空间，默认赋值函数可以满足需求，否则需要深拷贝。

3 赋值运算和拷贝构造不同：拷贝构造是指原来的对象不存在，用已存在的对象进行构造；赋值运算是指已经存在了两个对象，把其中一个对象的成员变量的值赋给另外一个对象的成员变量。

#include <iostream>

using namespace std;

//重载赋值运算符
class People {

public:
    int m_age;
    int m_score;
    int *m_ptr;

    People() {
        m_age = 18;
        m_score = 0;
        m_ptr = nullptr;
    }

    ~People() {
        if (m_ptr == nullptr) {
            delete m_ptr;
        }
    }

    void show() {
        cout << m_age << " " << m_score << endl;
        if (m_ptr != nullptr) {
            cout << *m_ptr << endl;
        }
    }

    People &operator=(const People &p) {
        //如果是自己给自己赋值
        if (this == &p) {
            return *this;
        }
        if (p.m_ptr == nullptr) {//如果源对象的指针为空，则清空目标对象的内存和指针
            if (m_ptr != nullptr) {
                delete m_ptr;
                m_ptr = nullptr;
            }
        } else {//源对象指针不为空
            //如果目标对象的指针为空，先分配内存
            if (m_ptr == nullptr) {
                m_ptr = new int;
            }
            //然后把源对象内存中的数据复制到目标对象的内存中
            memcpy(m_ptr, p.m_ptr, sizeof(int));
        }
        m_score = p.m_score;
        m_age = p.m_age;
        cout << "调用了重载赋值函数\n" << endl;
        return *this;
    }
};

void test() {
    People p1, p2;
    p1.m_score = 10;
    p1.m_age = 10;
    p1.m_ptr = new int(2);
    p1.show();
    p2.show();
    p2 = p1;
    p2.show();
}

int main() {
    test();
    return 0;
}
10 10
2
18 0
调用了重载赋值函数

10 10
2

 重载new&delete运算符

 

 

 

 

 

new[]和detele[]与 new和detele基本一致，在实际开发中，类用数组表示的 情况不多见，需要自定义分配内存的情况基本上没有，所以这两

为一个类重在new和delete时，尽管不必显示第使用static，但实际上仍在创建static成员函数 说明：

也就是说，声明这两个成员函数的时候，不管有没有写static关键字，它们都是静态成员函数，所以在这两个函数中，不能访问类的非静态成员。

#include <iostream>

using namespace std;

//为整型动态分配内存
void *operator new(size_t size) {
    cout << "调用了重载的new：" << size << "字节" << endl;
    void *p = malloc(size);
    cout << "申请到的内存地址是：" << p << endl;
    return p;
}

void operator delete(void *ptr) {
    cout << "调用了重载的delete" << endl;
//    if (ptr == 0) {//这是模拟C++的封装，所以C++中delete空指针也是安全的
    if (ptr == nullptr) {//这是模拟C++的封装，所以C++中delete空指针也是安全的
        return;
    }
    free(ptr);
}

void test() {
    //对于我们来说，C++的new和delete缺省屏蔽了全部细节，如果我们重载了new和delete运算符，就可以
    //用自己的代码申请和释放内存了。
    int *p = new int(1);
    cout << "p=" << p << ",*p=" << *p << endl;
    cout << "p=" << (void *) p << ",*p=" << *p << endl;
    delete p;


}

int main() {
    test();
    return 0;
}
/*
调用了重载的new：4字节
申请到的内存地址是：0x7fb2fc405910
p=0x7fb2fc405910,*p=1
p=0x7fb2fc405910,*p=1
调用了重载的delete
*/
#include <iostream>

using namespace std;

//为类动态分配内存  全局
void *operator new(size_t size) {
    cout << "调用了全局重载的new：" << size << "字节" << endl;
    void *p = malloc(size);
    cout << "申请到的内存地址是：" << p << endl;
    return p;
}

void operator delete(void *ptr) {
    cout << "调用了全局重载的delete" << endl;
//    if (ptr == 0) {//这是模拟C++的封装，所以C++中delete空指针也是安全的
    if (ptr == nullptr) {//这是模拟C++的封装，所以C++中delete空指针也是安全的
        return;
    }
    free(ptr);
}

class Person {
public:
    int m_age;
    int m_score;

    Person(int age, int score) {
        m_age = age;
        m_score = score;
        cout << "调用了构造函数Person(int age, int score)" << endl;
    }

    ~Person() {
        cout << "调用了析构函数~Person()" << endl;
    }

    void *operator new(size_t size) {
        cout << "调用了类重载的new：" << size << "字节" << endl;
        void *p = malloc(size);
        cout << "申请到的内存地址是：" << p << endl;
        return p;
    }

    void operator delete(void *ptr) {
        cout << "调用了类重载的delete" << endl;
//    if (ptr == 0) {//这是模拟C++的封装，所以C++中delete空指针也是安全的
        if (ptr == nullptr) {//这是模拟C++的封装，所以C++中delete空指针也是安全的
            return;
        }
        free(ptr);
    }
};

void test() {
    //对于我们来说，C++的new和delete缺省屏蔽了全部细节，如果我们重载了new和delete运算符，就可以
    //用自己的代码申请和释放内存了。
    int *p = new int(1);
    cout << "p=" << p << ",*p=" << *p << endl;
    cout << "p=" << (void *) p << ",*p=" << *p << endl;
    delete p;
    cout << endl;
    Person *p2 = new Person(1, 2);
    cout << "p2的地址是" << p2 << " " << p2->m_age << " " << p2->m_score << endl;
    delete p2;


}

int main() {
    test();
    return 0;
}
调用了全局重载的new：4字节
申请到的内存地址是：0x7ff198c05910
p=0x7ff198c05910,*p=1
p=0x7ff198c05910,*p=1
调用了全局重载的delete

调用了类重载的new：8字节
申请到的内存地址是：0x7ff198c05910
调用了构造函数Person(int age, int score)
p2的地址是0x7ff198c05910 1 2
调用了析构函数~Person()
调用了类重载的delete

3333333_
关注
专栏目录
cpp笔记-运算符重载
Skyler1017的博客
01-18 366
运算符重载 内置类型的运算符无法重载，只能操作自定义类型 不能重载的运算符 . .* ?: :: sizeof 不能有默认参数，否则会改变操作符的数量 普通函数重载 要求其中的数据成员时public的 classA operator + (const classsA & a, const classA & b){ return classA(a._a b....
C++_运算符重载
热门推荐
思考，思考，再思考~
07-23 8万+
什么是运算符的重载?         运算符与类结合，产生新的含义。 为什么要引入运算符重载？         作用：为了实现类的多态性(多态是指一个函数名有多种含义)怎么实现运算符的重载？方式：类的成员函数 或 友元函数（类外的普通函数）规则：不能重载的运算符有 .  和 .*
C++操作符重载
weixin_33995481的博客
05-23 98
1在类中重载+=操作符 赋值操作符必须定义为成员函数,无论形参为何种类型 赋值必须返回*this的引用 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 classLove{ public: intstr; intagi;...
CPP_运算符重载及友元
weixin_33862041的博客
09-09 168
运算符重载 两种重载方法1）成员函数 a + b =&gt; a.operator+(b); 一个参数 2）友元函数 a + b =&gt; operator+(a, b); 两个参数。 friend 将某个类或函数声明为另一个类的友元，就可以访问另一个类的private成员了。 不能重载运算符：., .*, ::, ?: （共四个） 事例重载操作符operator...
【c++】cpp运算符重载
最新发布
hutaotaotao的博客
04-26 1250
c++运算符重载
cpp代码-结构体运算符重载
07-16
我们将深入探讨运算符重载的原理，以及如何在`main.cpp`文件中实现这一功能。 首先，了解运算符重载的基本概念。运算符重载并不创建新的运算符，而是为已有的运算符赋予不同的操作。这通常通过在类或结构体中定义...
复数的运算 运算符重载.cpp
07-07
# 运算符重载 [TOC] ## 1.定义 运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定义函数实现的。运算符重载实质...
CPP.rar_运算符重载
09-24
在C++编程语言中，运算符重载是一项关键特性，它允许程序员为现有的运算符赋予新的含义，以便在自定义类型上使用。这使得代码更加简洁、易读，并且能够更好地表达意图。本文将深入探讨C++中的运算符重载，特别是关于...
C++运算符重载总结
wo_ai_luo_的博客
11-10 1328
一定要自定义一个拷贝构造函数，这样在重载运算符返回对象副本的时候，编译器会自动调用拷贝构造函数，否则会出现结果错误。把‘=’运算符重载为类成员变量，并且将返回值设计成为该类的引用。除了‘=’运算符以外，其他的运算符重载最好设计成为友元函数。这就是我们今天要讲的运算符重载的总结.友元关系不会被派生类继承。
CPP 学习 - 运算符重载
灰黑的博客
01-13 1297
友元 友元不受访问权限的控制(public / protected / private) 友元函数可以重载，但是友元属性不会被继承 不能访问友元类内部的私有函数 友元是单向的，有缘关系不能传递(A -> B -> C) 推不出 (A -> C) 子类不会继承父类的友元属性 友元的形式 友元函数 友元类 class 类名 { // ... friend 函数原型; friend class 类名; // .... }; 函数 成员函数 非成员函数（
cpp代码-重载操作符operator
07-16
cpp代码-重载操作符operator
CPP-基础：运算符重载详解
dixiongbi7761的博客
08-26 613
1.运算符重载定义： 　　C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。 运算符重载是通过创建运算符函数实现的，运算符函数...
CPP-基础：单目运算符重载
dixiongbi7761的博客
08-28 223
关于++运算符前置和后置重载的实现实例： 1 #include <iostream> 2 using namespace std; 3 //创建时钟类 4 class Clock 5 { 6 public: 7 Clock(int NewH=0,int NewM=0,int NewS=0);//构造函数 8 void...
cpp运算符重载
bailang322的专栏
06-08 515
Complex Complex::operator+(const Complex &other) {     int r = real_+other.real_;     int i  = img_ +other.img_;     return Complex(r,i); } 等价   C =  A.oprator + B
CPP运算符重载
SongyangJi
05-04 2682
文章目录函数的重载运算符重载运算符重载的作用运算符重载的方式典型运算符的重载转换构造函数类型转换函数 函数的重载 1.定义的重载函数必须具有不同的参数个数，或不同的参数类型。编译系统根据不同的参数去调用不同的重载函数，实现不同的功能。 2、仅返回值不同时，不能定义为重载函数。 运算符重载 函数重载是指完成不同功能的函数可以具有相同的函数名。 C++编译器根据函数的实参确定应该调用哪一个函数。 运算...
cpp►常见运算符的重载
itzyjr的专栏
06-14 406
■ 流插入运算符<<：insertion operator (<<) #include <iostream> int main() { std::cout << "Hello world!";// print Hello world! to console return 0; } 在这个程序中，我们包含了< iostream>以便能够访问std::cout。在主函数内部，我们使用std::cout以及插入操作符(<<)发送文本He
CPPDay04运算符重载（友缘，友元）
坚持硬核
01-27 345
目录 1.为什么要重载运算符： 2.运算符的本质：函数 3.如何重载运算符 4.友缘，友元 5.输出运算符重载 6. 一般运算符重载的规范： 7. 哪些运算符不能重载 8.运算符重载分类 9.运算符重载需知： 1.为什么要重载运算符： 我们希望自己抽象出来的类也可以使用运算符去操作。 2.运算符的本质：函数 3.如何重载运算符 函数名...
cpp——复合类型——函数——运算符重载
mardax的专栏
03-06 540
cpp——复合类型——函数——运算符重载
CPP中的操作符重载
qq_40467692的博客
10-07 747
1、重载的运算符是具有特殊名字的函数，它们的名字由关键字 operator 和其后要定义的运算符号共同组成，和其他函数一样，重载的运算符也包含返回类型，参数列表以及函数体。 2、当一个重载的运算符是成员函数时， this 指针绑定到左侧运算对象上，成员运算符函数的显式参数数量比运算对象数量少一个。 3、对于重载的运算符，我们不能改变其原生的优先级和结合律。 4、取地址运算符，逻辑运算符，逗号运算符，前置与后置运算符不要重载，因为重载后会使得与原生含义或者行为不一致。 5、如果一个类重载了 == 运算
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值