CPP 核心编程4-重载运算符

最新推荐文章于 2024-04-06 15:19:10 发布
原创 最新推荐文章于 2024-04-06 15:19:10 发布 · 1.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #学习

本文详细介绍了C++中运算符重载的概念与实践，包括成员函数与全局函数重载加法运算符、重载左移运算符、友元函数配合重载以及赋值运算符的正确实现方式。此外，还探讨了如何避免浅拷贝导致的内存重复释放等问题。

 成员函数重载+

#include "iostream"

using namespace std;

//加好运算符重载
//1 成员函数重载+号
//2 全局函数重载+号

class Person {
public:
    int m_A;
    int m_B;

    //1 成员函数重载+号
    Person operator+(Person &p) const {
        Person temp{};
        temp.m_A = this->m_A + p.m_A;
        temp.m_B = this->m_B + p.m_B;
        return temp;
    }

};

void test1() {
    Person p1{10, 10};
    Person p2{20, 20};
//    Person p3 = p1 + p2;//没重载运算符之前报错 Invalid operands to binary expression ('Person' and 'Person')
    Person p3 = p1 + p2;//本质是Person p3 = p1.operator+(p2);
    cout << p3.m_A << " " << p3.m_B << endl;
}

int main() {
    test1();
    return 0;
}
30 30

全局函数重载+

#include "iostream"

using namespace std;

//加好运算符重载
//1 成员函数重载+号
//2 全局函数重载+号

class Person {
public:
    int m_A;
    int m_B;

    //1 成员函数重载+号
//    Person operator+(Person &p) const {
//        Person temp{};
//        temp.m_A = this->m_A + p.m_A;
//        temp.m_B = this->m_B + p.m_B;
//        return temp;
//    }

};

Person operator+(Person &p1, Person &p2) {
    return {p1.m_A + p2.m_A, p1.m_B + p2.m_B};
    //等同于下面
//    Person temp{p1.m_A + p2.m_A, p1.m_B + p2.m_B};
//    return temp;
}

//成员函数重载+号
void test1() {
    Person p1{10, 10};
    Person p2{20, 20};
//    Person p3 = p1 + p2;//没重载运算符之前报错 Invalid operands to binary expression ('Person' and 'Person')
    Person p3 = p1 + p2;//本质是Person p3 = p1.o perator+(p2);
    cout << p3.m_A << " " << p3.m_B << endl;
}

//全局函数重载+号
void test2() {
    Person p1{10, 10};
    Person p2{20, 20};
    Person p3 = p1 + p2;//本质是Person p3 = operator+(p1, p2);
    cout << p3.m_A << " " << p3.m_B << endl;
}

int main() {
    //test1();
    test2();
    return 0;
}

运算符重载，也可以发生函数重载

#include "iostream"

using namespace std;

//加好运算符重载
//1 成员函数重载+号
//2 全局函数重载+号  
//可以同时存在

class Person {
public:
    int m_A;
    int m_B;

    //1 成员函数重载+号
//    Person operator+(Person &p) const {
//        Person temp{};
//        temp.m_A = this->m_A + p.m_A;
//        temp.m_B = this->m_B + p.m_B;
//        return temp;
//    }

    Person operator+(int a) const {
        return {this->m_A + a, this->m_B + a};
    }
};

Person operator+(Person &p1, Person &p2) {
    return {p1.m_A + p2.m_A, p1.m_B + p2.m_B};
    //等同于下面
//    Person temp{p1.m_A + p2.m_A, p1.m_B + p2.m_B};
//    return temp;
}

//成员函数重载+号
void test1() {
    Person p1{10, 10};
    Person p2{20, 20};
//    Person p3 = p1 + p2;//没重载运算符之前报错 Invalid operands to binary expression ('Person' and 'Person')
    Person p3 = p1 + p2;//本质是Person p3 = p1.o perator+(p2);
    cout << p3.m_A << " " << p3.m_B << endl;
}

//全局函数重载+号
void test2() {
    Person p1{10, 10};
    Person p2{20, 20};
    Person p3 = p1 + p2;//本质是Person p3 = operator+(p1, p2);
    cout << p3.m_A << " " << p3.m_B << endl;
}

Person operator+(Person &p, int a) {
    return {p.m_A + a, p.m_B + 10};
}

//运算符重载发生函数重载
void test3() {
    Person p1{10, 10};
    Person p2 = p1 + 10;//
    cout << p2.m_A << " " << p2.m_B << endl;
}

int main() {
    //test1();
//    test2();
    test3();
    return 0;
}

总结：

对于内置的数据类型的表达式的运算符是不可能改变的

不要滥用运算符重载

#include "iostream"

using namespace std;

//左移运算符重载
class Person {
public:
    //利用成员函数重载 左移运算符

    //p.operator<<(cout)  简化 p<<cout
    //因此通常不会利用成员函数重载左移运算符，因为无法实现cout在左侧
//    void operator<<(Person &p) {
//
//    }

    int m_A;
    int m_B;
};

//所以只能使用全局函数重载左移运算符
//返回 ostream& 是用来做链式调用
ostream &operator<<(ostream &cout, Person &p) {//本质 operator<<(cout,p)
    cout << "m_A=" << p.m_A << " m_B=" << p.m_B;
    return cout;
}

void test() {
    Person p{1, 2};
    Person p2{3, 4};
//    cout << p;//无重载时，Invalid operands to binary expression ('std::__1::ostream' (aka 'basic_ostream<char>') and 'Person')
    cout << p << "\n" << p2 << "\n" << "hello world" << endl;
}

int main() {
    test();
    return 0;
}
m_A=1 m_B=2
m_A=3 m_B=4
hello world

#include "iostream"

using namespace std;

//友元+重载
class Person {
    friend ostream &operator<<(ostream &cout, Person &p);

public:
    Person(int a, int b) {
        m_A = a;
        m_B = b;
    }

private:
    int m_A;
    int m_B;
};

ostream &operator<<(ostream &cout, Person &p) {
    cout << "m_A=" << p.m_A << " m_B=" << p.m_B;
    return cout;
}

void test() {
    Person p{1, 2};
    Person p2{3, 4};
    cout << p << "\n" << p2 << "\n" << "hello world" << endl;
}

int main() {
    test();
    return 0;
}
m_A=1 m_B=2
m_A=3 m_B=4
hello world

重载左移运算符配合友元

赋值运算符重载

 有问题代码如下

#include "iostream"

using namespace std;

//赋值运算符重载
class Person {
public:
    Person(int age) {
        m_Age = new int(age);
    }

    ~Person() {
        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
    }

    int *m_Age;
};

void test() {
    Person p{18};
    Person p2{20};
    cout << "p年龄为：" << *p.m_Age << endl;
    cout << "p2年龄为：" << *p2.m_Age << endl;
    p2 = p;//堆区内存重复释放
    cout << "p年龄为：" << *p.m_Age << endl;
    cout << "p2年龄为：" << *p2.m_Age << endl;
}

int main() {
    test();
    return 0;
}
p年龄为：18
p2年龄为：20
p年龄为：18
p2年龄为：18
main(42841,0x116209dc0) malloc: *** error for object 0x7fcd4f405910: pointer being freed was not allocated
main(42841,0x116209dc0) malloc: *** set a breakpoint in malloc_error_break to debug

#include "iostream"

using namespace std;

//赋值运算符重载
class Person {
public:
    Person() {

    }

    Person(int age) {
        m_Age = new int(age);
    }

    ~Person() {
        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
    }

    void operator=(const Person &p) {
        //编译器的 =赋值 提供的是浅拷贝  会发生内存重复释放的问题
//        m_Age = p.m_Age;
//        *m_Age = *p.m_Age;//如果m_Age没有初始化就会报错，比如提供了默认构造函数 如下面注释的代码
        /*
           Person p{10};
           Person p2{};
           p2 = p;
           这样地址直接复制就会报错
        */

        //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
        /*
         * Person p{};
            Person p2{10};
            p2 = p;
            下面代码也会报错
        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
        m_Age = new int(*p.m_Age);
        */
        // 最好 改成如下
        if (p.m_Age != nullptr) {
            if (m_Age != nullptr) {
                delete m_Age;
                m_Age = nullptr;
            }
            m_Age = new int(*p.m_Age);
        }

    }

    int *m_Age;
};

void test() {
    //提供无参构造，这样m_Age 可能为空
    Person p{};
    Person p2{10};
//    cout << "p年龄为：" << *p.m_Age << endl;
//    cout << "p2年龄为：" << *p2.m_Age << endl;
    p2 = p;//堆区内存重复释放
//    cout << "p年龄为：" << *p.m_Age << endl;
//    cout << "p2年龄为：" << *p2.m_Age << endl;
}

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

后来发现，上面代码也有瑕疵，就是不能自己赋值给自己

p1=p1;这样会报错，下下方有修复代码

下面代码虽然运行不报错，但是不支持连等操作

如：

int a = 10;
int b = 20;
int c = 30;
c = b = a;
cout << a << b << c << endl;  //a =10; b=10; c=10;
#include "iostream"

using namespace std;

//赋值运算符重载
class Person {
public:
    Person(int age) {
        m_Age = new int(age);
    }

    ~Person() {
        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
    }

    void operator=(const Person &p) {
        *m_Age = *p.m_Age;
    }

    int *m_Age;
};

void test() {
    //如果使用有参构造函数，确保m_Age不为空
    Person p{20};
    Person p2{10};
    cout << "p年龄为：" << *p.m_Age << endl;
    cout << "p2年龄为：" << *p2.m_Age << endl;
    p2 = p;//堆区内存重复释放
    cout << "p年龄为：" << *p.m_Age << endl;
    cout << "p2年龄为：" << *p2.m_Age << endl;
}

int main() {
    test();
    return 0;
}
p年龄为：20
p2年龄为：10
p年龄为：20
p2年龄为：20

支持连等操作

#include "iostream"

using namespace std;

//赋值运算符重载
class Person {
public:
    Person(int age) {
        m_Age = new int(age);
    }

    ~Person() {
        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
    }

    const Person &operator=(const Person &p) {
        *m_Age = *p.m_Age;
        return *this;
    }

    int *m_Age;
};

ostream &operator<<(ostream &cout, Person &p) {
    cout << *p.m_Age;
    return cout;
}

void test() {
    //如果使用有参构造函数，确保m_Age不为空
    Person p1{10};
    Person p2{20};
    Person p3{30};
    p3 = p2 = p1;
    cout << p1 << " " << p2 << " " << p3 << endl;
}

int main() {
    test();
//    int a = 10;
//    int b = 20;
//    int c = 30;
//    c = b = a;
//    cout << a << b << c << endl;  //a =10; b=10; c=10;
    return 0;
}

修改成支持自己赋值给自己的代码

#include "iostream"

using namespace std;

//赋值运算符重载
class Person {
public:
    Person() {

    }

    Person(int age) {
        m_Age = new int(age);
    }

    ~Person() {
        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
    }

    void operator=(const Person &p) {
        //编译器的 =赋值 提供的是浅拷贝  会发生内存重复释放的问题
//        m_Age = p.m_Age;
//        *m_Age = *p.m_Age;//如果m_Age没有初始化就会报错，比如提供了默认构造函数 如下面注释的代码
        /*
           Person p{10};
           Person p2{};
           p2 = p;
           这样地址直接复制就会报错
        */

        //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
        /*
         * Person p{};
            Person p2{10};
            p2 = p;
            下面代码也会报错

        if (m_Age != nullptr) {
            delete m_Age;
            m_Age = nullptr;
        }
        m_Age = new int(*p.m_Age);
        */

        // 最好 改成如下  后来发现下面代码也有问题就是 p1=p1;自己复制给自己。所以再修改
//        if (p.m_Age != nullptr) {
//            if (m_Age != nullptr) {
//                delete m_Age;
//                m_Age = nullptr;
//            }
//            m_Age = new int(*p.m_Age);
//        }

        if (p.m_Age != nullptr && p.m_Age != m_Age) {
            if (m_Age != nullptr) {
                delete m_Age;
                m_Age = nullptr;
            }
            m_Age = new int(*p.m_Age);
        }

    }

    int *m_Age;
};

void test() {
    //提供无参构造，这样m_Age 可能为空
    Person p{};
    Person p2{10};
//    cout << "p年龄为：" << *p.m_Age << endl;
//    cout << "p2年龄为：" << *p2.m_Age << endl;
    p2 = p2;//堆区内存重复释放
//    cout << "p年龄为：" << *p.m_Age << endl;
    cout << "p2年龄为：" << *p2.m_Age << endl;
}

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

 

#include "iostream"

using namespace std;

//重载关系运算符
class Person {
public:
    Person(string name, int age) {
        m_age = age;
        m_name = name;
    }

    bool operator==(const Person &p) const {
        return m_name == p.m_name && m_age == p.m_age;
    }

    bool operator!=(const Person &p) const {
        return !(*this == p);
    }

    string m_name;
    int m_age;
};

void test() {
    Person p1{"zs", 20};
    Person p2{"zs2", 20};
    if (p1 == p2) {
        cout << "相等" << endl;
    } else {
        cout << "不相等" << endl;
    }

    if (p1 != p2) {
        cout << "不相等" << endl;
    } else {
        cout << "相等" << endl;
    }

}

int main() {
    test();
    return 0;
}
不相等
不相等

【Socket bind() error: invalid operands to binary expression】【转载】
j8267643的博客
01-30 1141
​​全清理掉，要不就用全局的namespace调用socket的​。​​的声明，导致编译器认为你调用的是​。​​，而不是socket包下面的​。解决办法也很简单，要不把​。你的代码里应该用了​。
C++报错 invalid operands to binary expression
Karthus77的博客
04-22 3万+
invalid operands to binary expression 二进制表达式的操作数无效 顾名思义 错误出在操作符上 对类型的操作问题 比如两种不能比较的类型进行了比较，比如我这里
报错invalid operands to binary expression (const char * and const char[9])
weixin_44074560的博客
07-18 5833
报错invalid operands to binary expression (const char * and const char[9])
error: invalid operands to binary expression (‘vector＜int＞‘ and ‘int‘)
weixin_72040293的博客
04-06 1454
vector f(N) 和 vector f[N]的错误书写，引发的错误
【维生素C语言】第五章 - 操作符
有道无术, 术尚可求。有术无道, 止于术。
05-27 1万+
本章将对操作符进行详细的讲解，讲操作符单独拿出来精讲。最后添加了些简单的练习题（带有解析）供读者使用。
C++中 ->运算符什么意思
06-04
从提供的引用资料可以看到相关信息：引用[4]直接展示了'->'运算符的用法示例，用户主要关注点在于理解这个操作符的核心功能和使用场景。其他引用提及了位运算符、比较运算符等内容，但用户的需求已明确聚焦在'->'上...
cpp代码-字符串类 （运算符重载 =，[],==,!=,<<,>>）
07-16
在C++编程语言中，字符串类（`std::string`）是C++标准库中的一个核心部分，提供了许多用于操作和管理字符串的功能。本篇我们将深入探讨如何通过运算符重载来增强`std::string`类的行为，特别是重载`=`, `[]`, `==`,...
重载运算符
06-15
运算符重载是一种在编程语言中允许用户自定义数据类型（如类）支持标准运算符操作的技术。通过运算符重载，可以为用户定义的类型提供与内置类型类似的表达式书写方式，从而增强代码的可读性和简洁性[^1]。 #### 一...
自定义类重载运算符
最新发布
08-22
重载运算符的语法：使用关键字`operator`后接运算符符号 3. 运算符重载可以作为成员函数或全局函数（友元）实现 4. 赋值运算符(=)重载时需要注意自赋值检查和资源管理[^4] 5. 输入输出运算符(和>>)通常重载为...
高效C++编程：深入理解运算符重载的最佳实践
# 1. 运算符重载基础 运算符重载是C++语言的特色之一，它允许程序员为类定义运算符的特殊含义，使得自定义类型的对象可以使用标准...- 重载运算符的基本规则和注意事项 让我们从运算符重载的定义开始探索这一迷人
Xcode10,真机模拟器运行错误(std::basic_ostream)解决办法-附件资源
03-05
Xcode10,真机模拟器运行错误(std::basic_ostream)解决办法-附件资源
error: invalid operands to binary % (have ‘double‘ and ‘int‘)取模mod %
weixin_73051604的博客
01-20 6713
error: invalid operands to binary % (have 'double' and 'int')取模mod %
Day1:熟悉情况捋顺任务c++
weixin_44991673的博客
04-26 2549
解决报错：invalid operands to binary expression (‘std::ostream’ (aka ‘basic_ostream’) and ‘const char *’) std::cout语法错误，注意负号问题《 还是 》 #include <iostream> #include <cstdlib> using namespace std; int main() { double px; double py; double
C语言--[Error] invalid operands to binary ^ (have 'float' and 'float')--对指数运算和乘法运算的一些总结。
热门推荐
weixin_43641971的博客
03-07 4万+
[Error] invalid operands to binary ^ (have ‘float’ and ‘float’) #include&lt;stdio.h&gt; int main(void) { int a = 0, b=0, c = 0; float x = 0, y =0; /*注意：如果y = a*x*x*x+b*x*x+c;再这里写，那么输出的y就是0； ...
15种 C++ 常见报错
zeekliu的博客
04-15 1万+
15种 C++ 常见报错
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值