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

于 2022-12-05 19:25:18 发布
阅读量1.1k 收藏
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wade1010/article/details/128191811
版权

 成员函数重载+

#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;
}
不相等
不相等

3333333_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值