类和对象-运算符重载

运算符重载

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

4.5.1 加号运算符重载

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

 

 

成员函数加法重载运算

#include <iostream>
using namespace std;
int a = 10;
int b = 10;
int c = a + b;
class person
{
public:
    int m_a;
    int m_b;
    person operator+ (person& p)
    {
        person tempt;
        tempt.m_a = m_a + p.m_a;
        tempt.m_b = m_b + p.m_b;
        return tempt;
    }
};
int main()
{
    person p1;
    p1.m_a = 10;
    p1.m_b = 10;
    person p2;
    p2.m_a = 10;
    p2.m_b = 10;
    person p3 = p1 + p2; //本质上是 ：p1.operaor+(p2)

cout <<"p1.m_a +p2.m_a = " << p3.m_a << endl 29 << "p1.m_b +p2.m_b = " << p3.m_b << endl; 30 }

 

 全局函数加法重载运算

#include <iostream>
using namespace std;
int a = 10;
int b = 10;
int c = a + b;
class person
{
public:
    int m_a;
    int m_b;
};
person operator+ (person& p1, person& p2)
{
    person tempt;
    tempt.m_a = p1.m_a + p2.m_a;
    tempt.m_b = p1.m_b + p2.m_b;
    return tempt;
}
int main()
{
    person p1;
    p1.m_a = 10;
    p1.m_b = 10;
    person p2;
    p2.m_a = 10;
    p2.m_b = 10;
    person p3 = p1 + p2 ;//本质上是operator+(p1,p2)

cout <<"p1.m_a +p2.m_a = " << p3.m_a << endl 29 << "p1.m_b +p2.m_b = " << p3.m_b << endl; 30 }

 

 运算符的函数重载

#include <iostream>
using namespace std;
int a = 10;
int b = 10;
int c = a + b;
class person
{
public:
    int m_a;
    int m_b;
};
person operator+ (person& p1, int num )
{
    person tempt;
    tempt.m_a = p1.m_a + num ;
    tempt.m_b = p1.m_b + num;
    return tempt;
}
int main()
{
    person p1;
    p1.m_a = 10;
    p1.m_b = 10;
    person p3 = p1 + 10;
    cout <<"p1.m_a +num = "  << p3.m_a << endl
        << "p1.m_b +num = " << p3.m_b << endl;
}

 

 

总结1：对于内置的数据类型（比如int类型）的表达式的的运算符是不可能改变的

总结2：不要滥用运算符重载（比如加法写成减法等等，会让人看不懂）

左移运算符重载

作用：可以输出自定义数据类型

#include <iostream>
using namespace std;
//左移运算重载符
class person
{
    friend ostream& operator<<(ostream& cout, person& p);
    //friend void test01();可以这样做也可以下面那样做
public://也可以这样做
        person(int a, int b)
    {
            m_a = a;
            m_b = b;
    }
private:
    //利用成员函数重载 左移运算符
    //如果不知道函数会返回什么先写void
    //如果是这样void operator<<(person& p)，那么就会变成p.operator<<(p)
    //如果是这样void operator<<(cout)，那么就会变成p.operator<<(cout),简化版本为，p<<cout,与希望的cout << p不符
    //通常不会用成员函数调用重载<<运算符，因为无法实现cout在左侧
    /*void operator<<(person&p)
    {

    }*/
    int m_a;
    int m_b;
};
//只能利用全局函数重载左移运算符
ostream &operator<<(ostream& cout, person& p)//本质是 operator << (cout , p) 简化 cout << p
{
    cout << "m_a = " << p.m_a << ",m_b = " << p.m_b << endl;
    return cout;
}
//ostream& operator<<(ostream& out, person& p)//本质是 operator << (cout , p) 简化 cout << p
//{
//    out << "m_a = " << p.m_a << ",m_b = " << p.m_b << endl;
//    return out; 也可以 ，因为引用的就是给它起别名，这本质上还是cout
//}
void test01()
{
    person p(10,10);
    /*p.m_a = 10;
    p.m_b = 10;*/
    cout << p << endl;
}
int main()
{
    test01();
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型

 递增运算符重载

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

 

 

前置递增

#include <iostream>
using namespace std;
class myinteger
{
    /*friend void test01();*/
    friend ostream& operator<<(ostream& cout, myinteger myint);
public:
    myinteger()
    {
        m_num = 0;
    }
    //重载前置++运算符，先输出原数据在加1
    myinteger& operator++() //地址传递，指向的是地址，不会创建新副本，对该地址持有者进行直接更改
    {
        //先进行++运算
        m_num++;
        //再将自身做返回
        return *this;
    }

private:
    int m_num;
};
//重载左移运算符
ostream& operator<<(ostream& cout, myinteger myint)
{
    cout << myint.m_num;
    return cout;
}
void test01()
{
    int a = 0;
    cout << "++(++a) =" << ++(++a) << endl;
    cout << "a =" << a << endl;
    myinteger myint;
    cout << " ++(++myint ) =" <<++(++myint) << endl;
    cout <<"myint = " <<  myint << endl;
}

int main()
{
    test01();
}

 

myinteger operator++()
    {
        //先进行++运算
        m_num++;
        //再将自身做返回
        return *this;
    }

void test01()
{
    int a =0; //内置数据类型，所以++都是对同一个a进行的
    cout << "++(++a) =" << ++(++a) << endl;
    cout << "a =" << a << endl;//所以结果也是2
    myinteger myint;//通过值传递进行，每执行完一次操作后都会创造新的副本
    cout << " ++(++myint ) =" <<++(++myint) << endl;//(++myint )后创造一个新的myint在进行++操作，也就是说相当于，对同一个myint只进行了一次++操作，所以++(++myint ) = 2，但是myint却只等于1
    cout <<"myint = " <<  myint << endl;
}

 

后置递增

 

    myinteger operator++(int)//后置递增需要返回 值，而不是地址，因为返回的是局部对象
    {
        //先记录当时结果
        myinteger temp = *this;//，操作完之后就被释放掉了，后面返回操作就是非法的了
        //后进行递增运算
        m_num++;
        //最后将记录的结果返回
        return temp;
    }
void test02()
{
    int a = 0;
    cout << "a++ =" << a++  << endl;
    cout << "a =" << a << endl;
    myinteger myint;
    cout << "myint++ =" << myint++<< endl;//因为值传递每次执行后会创建新副本所以不能(myint++)++链式相加
    cout << "myint = " << myint << endl;
}
int main()
{
    test02();
}

总结： 前置递增返回引用，后置递增返回值

赋值运算符重载

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

1. 默认构造函数(无参，函数体为空)
2. 默认析构函数(无参，函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符 operator=, 对属性进行值拷贝

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

#include <iostream>
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;//this指向对象本身
    }
    int* m_age;
};
void test01()
{
    person p1(18);
    person p2(20);
    person p3(30);
    p3 = p2 = p1;//赋值操作
    cout << "p1's age = " << *p1.m_age << endl;
    cout << "p2's age = " << *p2.m_age << endl;
    cout << "p3's age = " << *p3.m_age << endl;
}
int main()
{
    test01();
    //对于内置的数据类型默认可以运行连等于操作
    /*int a = 10;
    int b = 20;
    int c = 30;
    c = b = a;
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;*/
}

 

 

 

 

 

 

 

关系运算符重载

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

#include <iostream>
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;
        }
        else
            return false;
    }
    bool operator!=(person& p)
    {
        if (this->m_name != p.m_name && this->m_age != p.m_age)
        {
            return true;
        }
        return false;
    }
    string m_name;
    int m_age;
};
void test01()
{
    person p1("tom", 18);
    person p2("tom", 18);
    if (p1 == p2)
    {
        cout << "p1 == p2 " << endl;
    }
}
void test02()
{
    person p3("tom", 18);
    person p4("jerry", 18);
    if (p3 == p4)
    {
        cout << "p3 == p4 " << endl;
    }
    else
    {
        cout << "p3 != p4 " << endl;
    }
}
void test03()
{
    person p5("tom", 18);
    person p6("jerry", 18);
    if (p5 != p6)
    {
        cout << "p5 != p6 " << endl;
    }
    else
    {
        cout << "p5 == p6 " << endl;
    }
}
int main()
{
    test01();
    test02();
    test03();
}

 

 

函数调用运算符重载

• 函数调用运算符 () 也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

#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 mprint;
    mprint("hello world");
}
void test02()
{
    myprint mprint;
    mprint("hello world");//由于使用起来非常类似于函数调用，因此称之为仿函数
    myprint02("hello world");//函数调用
}
////仿函数非常灵活，没有固定写法
////加法类
class myadd
{
public:
    int operator()(int num1, int num2)
    {
        return num1 + num2;
    }
};
void test03()
{
    myadd myad;
    int ret = myad(100, 100);
    cout <<"ret = " <<  ret << endl;
    //匿名函数对象
    cout << myadd()(100, 100) << endl;//当前行执行完了立马释放
}
int main()
{
    test01();
    test02();
    test03();
}