14. 运算符重载（二）

3. 递增运算符重载（++、--）

作用：通过重载递增运算符，实现自己的整型数据
注意：前置递增返回引用，后置递增返回值

//  首先你要搞明白 前置++ 与 后置++ 区别；
int a = 10;
cout << ++a <<endl; // 11
cout << a <<endl; // 11
int b = 10;
cout << b++ <<endl; // 10
cout << b <<endl; // 11

#include <iostream>
using namespace std;
// 自定义整型
class Myinteger
{
      friend ostream& operator<<(ostream& cout,Myinteger myint)
public:
      Myinteger()
      {
            m_NNum = 0;
      }
      //重载前置 ++ 运算符
      // 返回引用为了已知对一个数据进行递增操作，详情请看 test01 中的第一个和第二个 cout
      Myinteger& operator++ ()  //注意返回值类型
      {
            m_Num++;
            return *this;  // 这里还是返回自己，this是指针进行解引用
      }

      //重载后置 ++ 运算符
      //int 代表占位参数，可以用于区分前置和后置递增
      //这里为什么返回的是值？是由于 temp 是局部对象
      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;
      cout << myint <<endl;
}

void test02()
{
      Myinteger myint;
      cout << myint++ << endl;
      cout << myint <<endl;
}
int main()
{
      test01();
      test02();
      system("pause");
      return 0;
}

4. 赋值运算符重载

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

• 默认构造函数（无参，函数体为空）
• 默认析构函数（无参，函数体为空）
• 默认拷贝构造函数，对属性进行值拷贝
• 赋值运算符 operator=，对属性进行拷贝
  如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

class Person 
{
public:
      Person (int age)
      {
            m_Age = new int (age); /开辟堆区，堆区需要由程序员手动释放
      }
      int *m_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; //返回对象本体
      }
};
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();
      system("pause");
      return 0;
}

---

5. 关系运算符的重载（== 或 != ）

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

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

//重载关系运算符
class Person 
{
public:
      Person(string name,int age)
      {
            m_Name = name;
            m_Age = age;
      }
      string m_Name;
      int m_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;
};
void test01()
{
      Person p1("Tom",18);
      Person p2("Jerry",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;
}

---

6. 函数调用运算符重载

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

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

class Myprint
{
public:
      //函数调用运算符重载
      void operator ()(string test)
      {      
            cout << test endl;
      }
      
};
class Myadd
{
public:
      //函数调用运算符重载
      int operator ()(int num1,int num2)
      {      
            return num1 + num2;
      }
      
};
void test01()
{
      Myprint myprint;
      myprint("hello world"); //由于重载后使用的方式非常像函数的调用，因此称为仿函数
}
//仿函数没有固定写法，非常灵活
void test02()
{
      Myadd myadd;
      int ret = myadd(100,100);
      cout << "ret =" <<ret <<endl;
      
      //类型() ————> 匿名函数对象：当前行执行完立即释放
      cout << Myadd()(100,100) << endl;
}
int mian()
{
      test01();
      test02();
      system("pause");
      return 0;
}