类和对象-C++运算符重载

乘～风

已于 2024-03-12 20:35:06 修改

阅读量392

点赞数 7

分类专栏：编程语言文章标签：开发语言 C++

于 2024-03-08 20:49:13 首次发布

本文链接：https://blog.csdn.net/axzy5863/article/details/136531641

版权

编程语言专栏收录该内容

27 篇文章 0 订阅

订阅专栏

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

class Person
{
public:

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

    ~Person()
    {
        if(m_Age!=NULL)
        {
            delete m_Age;
            m_Age=NULL;
        }
    }
    //重载 赋值运算符
    Person& operator =(Person &p)
    {
        //编译器提供深拷贝
        //m_Age=p.m_Age;

        //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
        if(m_Age!=NULL)
        {
            delete m_Age;
            m_Age=NULL;
        }

        //深拷贝
        m_Age=new int(*p.m_Age);
        return *this;
    }

    int *m_Age;
};

void test01()
{
    Person p1(18);

    Person p2(20);

    Person p3(30);

    p3=p2=p1;//赋值操作

    cout<<"p1的年龄为： "<<*p1.m_Age<<endl;

    cout<<"p2的年龄为： "<<*p2.m_Age<<endl;

    cout<<"p3的年龄为： "<<*p3.m_Age<<endl;
}

int main()
{
    test01();

    /*int a=10;
    int b=10;
    int c=10;

    c=b=a;//内置函数支持连等式

    cout<<"a= "<<a<<endl;
    cout<<"b= "<<b<<endl;
    cout<<"c= "<<c<<endl;*/

    system("pause");
    return 0;
}

师从黑马

运算符重载

概念：对已有的运算符重新进行定义，赋予另一种功能，以适应不同的数据类型

加号运算符重载

作用：实现两个自定义数据类型相加的运算

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

class Person
{
public:


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

    int m_A;
    int m_B;
};

// 2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
    Person temp;
    temp.m_A = p1.m_A + p2.m_A;
    temp.m_B = p1.m_B + p2.m_B;
    return temp;
}

//函数重载的版本
Person operator+(Person &p1,int num)
{
    Person temp;
    temp.m_A = p1.m_A + num;
    temp.m_B = p1.m_B + num;
    return temp;
}

void test01()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;

    //成员函数重载本质调用
   // Person p3=p1.operator+(p2);
    //全局函数的本质调用
    //Person p3=operator+(p1,p2);
    //简化
    Person p3 = p1 + p2;

    //运算符重载，也可以发生函数重载
    Person p4=p1+100;//Person +int

    cout << "p3.m_A= " << p3.m_A << endl;
    cout << "p3.m_B= " << p3.m_B << endl;

    cout << "p4.m_A= " << p4.m_A << endl;
    cout << "p3.m_B= " << p4.m_B << endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}

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

左移运算符重载

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

class Person
{
    friend ostream &operator<<(ostream &ut,Person &p);


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

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

private:

    int m_A;
    int m_B;
};

//只能利用全局函数重载左移运算符
ostream &operator<<(ostream &ut,Person &p)//本质 operator<<(cout,p)简化cout<<P
{
    ut<<"m_A="<<p.m_A<<"m_B= "<<p.m_B;
}
void test01()
{
    Person p(10,10);

    cout<<p<<endl;
}

int main()
{
    test01();

    system("pause");
    return 0;
}

递增运算符重载

作用：通过递增运算符重载，实现自己的整型数据

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

//自定义整型
class MyInteger
{
    friend ostream& operator<<(ostream& cout,MyInteger myint);
public:
    MyInteger()
    {
        m_Num=0;
    }

    //重载前置++运算符   返回引用为了一直对一个数据进行递增操作
   MyInteger& operator++()
    {
        //先进行++运算
        m_Num++;
        //再将自身做一个返回
        return *this;

    }

    //重载后置++运算符
    MyInteger operator++(int)//int 代表占位参数，可以用于区分前置递增和后置递增
    {
        //先 记录当时结果
        MyInteger temp=*this;
        //后 递增
        m_Num++;
        //最后将记录结果做返回
        return temp;
    }


private:
    int m_Num;
};

//重载<<运算符
ostream& operator<<(ostream& cout,MyInteger myint)
{
    cout<<myint.m_Num;
    return cout;
}
void test01()
{
    MyInteger myint;

    cout<<++myint<<endl;
}

void test02()
{
    MyInteger myint;

    cout<<myint++<<endl;
    cout<<myint<<endl;

}


int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

前置递增返回的是引用，后置递增返回的是值

递减运算符重载

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

//自定义整型
class MyInteger
{
    friend ostream& operator<<(ostream& cout,MyInteger myint);
public:
    MyInteger()
    {
        m_Num=0;
    }
    //前置递减
    MyInteger& operator--()
    {
        m_Num--;
        return *this;
    }
    //后置递减
    MyInteger operator--(int)
    {
        MyInteger temp=*this;
        m_Num--;
        return temp;
    }

private:
    int m_Num;

};
//重载<<运算符
ostream& operator<<(ostream& cout,MyInteger myint)
{
    cout<<myint.m_Num;
    return cout;
}
void test01()
{
    MyInteger myint;
    cout<<--myint<<endl;
}
void test02()
{
      MyInteger myint;

    cout<<myint--<<endl;
    cout<<myint<<endl;

}

int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

赋值运算符重载

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

1、默认构造函数 2、默认析构函数 3、默认析构函数，对属性进行值拷贝

4、赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝的问题

关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

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

class Person
{
public:
    Person(string name,int age)
    {
        m_Name=name;
        m_Age=age;
    }

    //重载==

    bool operator==(Person &p)
    {
        if(this->m_Name==p.m_Name&&this->m_Age==p.m_Age)
        {
            return true;
        }
        return false;
    }

    bool operator!=(Person &p)
    {
        if(this->m_Name==p.m_Name&&this->m_Age==p.m_Age)
        {
            return false;
        }
        return true;
    }
    string m_Name;
    int m_Age;

};


void test01()
{
    Person p1("Tom",18);

    Person p2("Terry",18);

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

}
int main()
{
    test01();

    system("pause");
    return 0;
}

函数调用运算符重载

函数调用运算符（）也可以重载

由于重载后使用的方式非常像函数的调用，因此称为仿函数

仿函数没有固定的写法，非常灵活

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

class MyPrint
{
public:

    //重载函数调用运算符
    void operator()(string test)
    {
        cout<<test<<endl;
    }
};

void MyPrint02(string test)
{
    cout<<test<<endl;
}

void test01()
{
    MyPrint myprint;

    myprint("hello world");//由于重载后使用的方式非常像函数的调用，因此称为仿函数

    MyPrint02("hello world");

}

//仿函数没有固定的写法，非常灵活

//加法类
class MyAdd
{
public:
    int operator()(int num1,int num2)
    {
        return num1+num2;
    }
};

void test02()
{
    MyAdd myadd;
    int ret =myadd(100,100);
    cout<<"ret="<<ret<<endl;

    //匿名函数对象
    cout<<MyAdd()(100,100)<<endl;
}

int main()
{
    test01();
    test02();

    system("pause");
    return 0;
}

若有侵权，请联系作者