C++运算符重载1-- ＜＜,++,--,*,-＞

基本概念

在 c++ 中，可以定义一个处理类的新运算符。这种定义很像一个普通的函数定义，

只是函数的名字由关键字 operator 及其紧跟的运算符组成。

差别仅此而已。它像 任何其他函数一样也是一个函数，当编译器遇到适当的模式时，就会调用这个函数。

该函数的名字是 operator@，其中@代表了被重载的运算符。

运算符重载与友元函数

友元函数是一个全局函数，和我们上例写的全局函数类似，只是友元函数可以访问

某个类私有数据。 案例 : 重载左移操作符 (<<), 使得 cout 可以输出对象。

可重载的运算符

自增自减(++/--)运算符重载

当编译器看到 ++a(前置 ++) ，它就调用 operator++(a), 当编译器看到 a++ （后置 ++ ），它就会去调

用 operator++(a,int)

其标准形式为 :

#include <iostream>

using namespace std;
class Data
{
    friend ostream& operator<<(ostream &out, Data &ob);
private:
    int a;
    int b;
public:
    Data()
    {
        cout<<"无参的构造函数"<<endl;
        a = 0;
        b=0;
    }
    Data(int a,int b):a(a),b(b)
    {
        cout<<"有参构造"<<endl;
        //this->a = a;
        //this->b = b;
    }
    void showData(void)
    {
        cout<<"a = "<<a<<", b= "<<b<<endl;
    }
    ~Data()
    {
        cout<<"析构函数函数"<<endl;
    }

    //成员函数 重载前置++  ++ob1  (先加  后使用)
    //编译器 默认识别 operator++(a) //但是a可以用this代替 从而化简 operator++()
    Data& operator++()//++ob1
    {
        //先加
        a++;//this->a = this->a +1
        b++;//this->b = this->b +1
        //后使用
        return *this;
    }
    //成员函数 重载后置++  ob1++  (先使用 后加)
    //编译器 默认识别 operator++(a,int) //但是a可以用this代替 从而化简 operator++(int)
    Data& operator++(int)//ob1++
    {
        //先使用(备份加之前的值)
        static Data old=*this;//指针解引用后，是这个对象

        //后加
        a++;
        b++;

        //返回备份值
        return old;
    }

    //重载前置--    --ob3
    //编译器 默认识别 operator++(a) //但是a可以用this代替 从而化简 operator--()
    Data& operator--()
    {
        //先减
        a--;
        b--;

        //后使用(返回)
        return *this;
    }

    //重载后--    ob4--
    //编译器 默认识别 operator++(a,int) //但是a可以用this代替 从而化简 operator++(int)
    Data& operator--(int)
    {
        //先使用
        static Data old=*this;//注意这里的static，必须要加，否则函数调用结束，就会释放，导致程序错误。

        //再减
        a--;
        b--;

        return old;
    }


};
//普通全局函数 作为类的友元 重载<<运算符
ostream& operator<<(ostream &out, Data &ob)
{
    out<<"a = "<<ob.a<<", b = "<<ob.b;
    return out;
}
void test01()
{
    Data ob1(10,20);
    ob1.showData();

    //重载<<直接输出自定义对象的值
    //operator<<(cout,ob1);
    cout<<ob1<<endl;

    //成员函数 重载 ++运算符
    cout<<++ob1<<endl;

    Data ob2(10,20);
    cout<<ob2++<<endl;
    cout<<ob2<<endl;

    //成员函数 重载 --运算符
    Data ob3(10,20);
    cout<<"ob3 "<<ob3<<endl;
    cout<<--ob3<<endl;

    Data ob4(10,20);
    cout<<"ob4 "<<ob4<<endl;
    cout<<ob4--<<endl;
    cout<<"ob4 "<<ob4<<endl;


}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

指针运算符(*、->)重载

设计一个智能指针解决new出来的堆区空间释放问题（局部空间结束后，借助析构函数释放空间）

#include <iostream>

using namespace std;
class Person
{
private:
    int num;
public:
    Person(int num):num(num)
    {
        //this->num = num;
        cout<<"有参构造num = "<<num<<endl;
    }

    void showPerson(void)
    {
        cout<<"num = "<<num<<endl;
    }
    ~Person()
    {
        cout<<"析构函数 num = "<<num<<endl;
    }
};

//设计一个智能指针 解决 Person new出的堆区空间 释放问题
class SmartPointer{
public:
    Person *pPerson;
public:
    SmartPointer(Person *p)
    {
        pPerson = p;
    }

    ~SmartPointer()
    {
        if(pPerson != NULL)
        {
            delete pPerson;
            pPerson = NULL;
        }
    }

    //成员函数重载->运算符
    Person* operator->()
    {
        return this->pPerson;
    }

    //成员函数 重载 *运算
    Person& operator*()
    {
        return *(this->pPerson);
    }
};
void test01()
{
    Person *p = new Person(100);
    p->showPerson();

    //假如我忘了 delete p
    //delete p;

    //需求：自动的帮我释放 堆区空间（智能指针的概念）
    SmartPointer pointer(new Person(200));

    //访问Person类中的showPerson()
    //pointer.pPerson->showPerson();

    //保证指针的使用
    //(pointer.operator ->())->showPerson();
    pointer->showPerson();
    (*pointer).showPerson();

}
int main(int argc, char *argv[])
{
    test01();
    return 0;
}

智能指针的概念：自动释放堆区空间，防止空间未释放，导致内存泄漏。