C++学习笔记14——C++中的操作符重载

操作符重载的概念

• C++中的重载能够扩展操作符的功能

• 操作符的重载以函数的方式进行

• 本质：用特殊形式的函数扩展操作符的功能

• 通过operator关键字定义特殊的函数来**重载操作符

• 语法：

// Sign为系统中预定义的操作符
Type operator Sign(const Type& p1, const Type& p2)
{
    Type ret;

    return ret;
}

• 可以将操作符重载函数定义为类的成员函数

  • 比全局操作符重载函数少一个参数（左操作数）

  • 编译器优先在成员函数中寻找操作符重载函数

• 操作符重载的注意事项

  • 操作符重载不能改变原操作符的优先级

  • 操作符重载不能改变操作数的个数

  • 操作符重载不能改变操作符的原有语义

---

数组操作符（[]）重载

• 数组操作符是C/C++中的内置操作符

• 数组操作符的原生意义是数组访问和指针运算

  • a[n] <==> (a + n) <==> (n + a) <==> n[a]

• 数组访问操作符的重载能够使得对象模拟数组的行为

  • 只能通过类的成员函数重载

  • 重载函数能且仅能使用一个参数

  • 可以定义不同参数的多个重载函数

/*
    测试代码
*/

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int a[5];
public:

    int& operator [] (int i)
    {
        return a[i];
    }

    int& operator [] (const string& s)
    {
        if( s == "1st" )
        {
            return a[0];
        }
        else if( s == "2nd" )
        {
            return a[1];
        }
        else if( s == "3rd" )
        {
            return a[2];
        }
        else if( s == "4th" )
        {
            return a[3];
        }
        else if( s == "5th" )
        {
            return a[4];
        }

        return a[0];
    }

    int length()
    {
        return 5;
    }
};

int main()
{
    Test t;

    for(int i=0; i<t.length(); i++)
    {
        t[i] = i;
    }

    for(int i=0; i<t.length(); i++)
    {
        cout << t[i] << endl;
    }

    cout << endl;   

    cout << t["5th"] << endl;
    cout << t["4th"] << endl;
    cout << t["3rd"] << endl;
    cout << t["2nd"] << endl;
    cout << t["1st"] << endl;

    return 0;
}

运行结果

0
1
2
3
4

4
3
2
1
0

---

赋值操作符（=）重载

• C++规定赋值操作符（=）只能重载为成员函数

• 编译器为每个类默认重载了赋值操作符

• 默认的赋值操作符仅完成浅拷贝

• 当需要进行深拷贝时必须重载赋值操作符

• 赋值操作符重载与拷贝构造函数有相同的存在意义

/*
    测试代码
*/

#include <iostream>

using namespace std;

class Test
{
private:

    int* m_pointer;

public:

    Test()
    {
        m_pointer = NULL;
    }
    Test(int i)
    {
        m_pointer = new int(i);
    }

    //自定义拷贝构造函数 
    Test(const Test& obj)
    {
        m_pointer = new int(*obj.m_pointer);
    }

    // 赋值操作符重载
    Test& operator = (const Test& obj)
    {
        if(this != &obj)
        {
            delete m_pointer;

            m_pointer = new int(*obj.m_pointer)
        }

        retutn *this;
    }

    void print()
    {
        cout << "m_pointer = " << m_pointer << endl;
    }

    ~Test()
    {
        delete m_pointer;
    }
};

int main()
{
    Test t1(1);

    Test t2;
    t2 = t1;

    t1.print();
    t2.print();

    return 0;
}

运行结果

m_pointer = 0x3810e8
m_pointer = 0x381108