C++操作符重载之下标操作符 ([], [][])

自定义类型MyClass中如果含有STL顺序容器成员sequential_container<type>，可能希望定义MyClass::operator[]操作符；如果STL顺序容器是多维的sequential_constainer<sequential_constainer<...<type>...>，可能希望定义MyClass的[][]...操作符。

[]

---

 

重载[]操作符：

1. 双目操作符，第一操作数是重载此操作符的对象，第二操作数是无符号下标。

2. C++不允许把下标操作符函数作为外部函数来定义,它只能是非静态的成员函数。

3. 为了能对数组赋值,一般将返回值声明为引用类型。

 

ReTurnType& MyClass::operator[](unsigned int idx);

 

例一：

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

class Data1d{

    vector<double> data1d;
    int length1d;

    public:
    Data1d(int lg=0, double elem=0):length1d(lg){
        for (int i=0; i<lg; i++)
          data1d.push_back(elem);
        //length1d=data1d.size();
    }

    void pushback(double elem){data1d.push_back(elem); ++length1d;}
    void popback(){data1d.pop_back(); --length1d;}
    int length(){return length1d;}

    double& operator[](const int idx){
        if (idx < 0 || idx >= length1d){
            cerr << "ERROR: Index Out of Range, Last Element Returned!" << endl;
            return data1d[length1d - 1];
        }
        return data1d[idx];
    }
    friend ostream& operator<<(ostream&, Data1d&);
};

ostream& operator<<(ostream& o, Data1d& mydata1d){
    cout << "Data(" << mydata1d.length1d << "):\t";
    for (int i=0; i<mydata1d.length1d; i++)
      o << mydata1d[i] << ' ';
    return o;
}

int main(){
    Data1d mydata1d(5,0);
    cout << mydata1d << endl;

    for (int i=1; i<=5; i++)
      mydata1d.pushback(i);
    cout << mydata1d << endl;

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

    mydata1d.popback();
    cout << mydata1d << endl;
}

输出：

Data(5):        0 0 0 0 0
Data(10):       0 0 0 0 0 1 2 3 4 5
ERROR: Index Out of Range, Last Element Returned!
Data(10):       0 1 2 3 4 5 6 7 8 10
Data(9):        0 1 2 3 4 5 6 7 8

 [][]

---

 

[][]操作符。[][]无法作为一个操作符整体来定义或重载，因为C++不允许定义新的操作符。[][]的实现实际上是后面一个[]作用于前面一个[]的返回值上，以下例子中[][]是这样实现的：MyClass重载operator[]，其返回类型为&vector<type>, 继续使用非重载的vector<type>::operator[], 得到type&.

例二：

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>

using namespace std;

class Data2d{

    vector<vector<double>> data2d;
    int lengthx, lengthy;

public:
    Data2d(int lgx = 0, int lgy=0, double elem = 0):lengthx(lgx), lengthy(lgy){
        vector<double> data1d;
        for (int i = 0; i < lgx; i++){
            data1d.clear();
            for (int j = 0; j < lgy; j++)
                data1d.push_back(elem);
            data2d.push_back(data1d);
        }
    }

    vector<int> size(){ return vector<int>{lengthx, lengthy}; }

    //reload operator[] and we can use "operator"[][]
    vector<double>& operator[](const int idx){ return data2d[idx]; }

    friend ostream& operator<<(ostream&, Data2d&);
};

ostream& operator<<(ostream& o, Data2d& mydata2d){
    cout << "Data(" << mydata2d.lengthx << ", " << mydata2d.lengthy << ")" << endl;

    for (int i = 0; i < mydata2d.lengthx; i++){
        for (int j = 0; j < mydata2d.lengthy; j++)
            o << mydata2d.data2d[i][j] << '\t';
        o << endl;
    }
    return o;
}

int main(){
    Data2d mydata2d(3, 5, 0);
    cout << mydata2d << endl;

    vector<int> sz = mydata2d.size();
    for (int i = 0; i < sz[0]; i++)
        for (int j = 0; j < sz[1]; j++)
            mydata2d[i][j] = i+j;
    cout << mydata2d << endl;
}

输出：

Data(3, 5)
0       0       0       0       0
0       0       0       0       0
0       0       0       0       0

Data(3, 5)
0       1       2       3       4
1       2       3       4       5
2       3       4       5       6