Sovraccarico dell'operatore di accesso ai membri della classe -> in C++

Sovraccarico dell'operatore e funzione C++

L'operatore di accesso ai membri della classe (->) può essere sovraccaricato, ma è piuttosto complicato. È definito per dare alla classe un comportamento "puntatore". L'operatore -> deve essere una funzione membro. Se viene utilizzato l'operatore ->, il tipo di ritorno deve essere un puntatore o un oggetto della classe.

L'operatore -> viene solitamente utilizzato insieme all'operatore di riferimento * per implementare la funzionalità di "puntatore intelligente". Questi puntatori sono oggetti che si comportano come puntatori normali, ma con la differenza che, quando si accede all'oggetto tramite il puntatore, eseguono altre operazioni. Ad esempio, quando il puntatore viene distrutto o quando il puntatore punta a un altro oggetto, l'oggetto viene automaticamente eliminato.

L'operatore di riferimento indiretto -> può essere definito come un operatore postfisso unario. Questo significa che, dato un'istanza di classe:

class Ptr{
　　　//...
　　　X * operatore->();
};

Classe Ptr L'oggetto può essere utilizzato per accedere alla classe X dei membri, viene utilizzata in modo simile a come si utilizzerebbe un puntatore. Ad esempio:

void f(Ptr p)
{
　　　p->m = 10; // (p.operator->())->m = 10
}

La sintassi p->m viene interpretata come (p.operator->())->m. Allo stesso modo, il seguente esempio dimostra come sovraccaricare l'operatore di accesso ai membri della classe ->.

#include <iostream>
#include <vector>
using namespace std;
　
// 假设一个实际的类
class Obj {
　　　static int i, j;
public:
　　　void f() const { cout << i++ << endl; }
　　　void g() const { cout << j++ << endl; }
};
　
// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;
　
// 为上面的类实现一个容器
class ObjContainer {
　　　vector<Obj*> a;
public:
　　　void add(Obj* obj)
　　　{　
　　　　　　a.push_back(obj); // 调用向量的标准方法
　　　}
　　　friend class SmartPointer;
};
　
// 实现智能指针，用于访问类 Obj 的成员
class SmartPointer {
　　　ObjContainer oc;
　　　int index;
public:
　　　SmartPointer(ObjContainer& objc)
　　　{　
　　　　　　　oc = objc;
　　　　　　　index = 0;
　　　}
　　　// 返回值表示列表结束
　　　bool operator++() // 前缀版本
　　　{　
　　　　　if(index >= oc.a.size() - 1) return false;
　　　　　if(oc.a[++index] == 0) return false;
　　　　　return true;
　　　}
　　　bool operator++(int) // 后缀版本
　　　{　
　　　　　　return operator++();
　　　}
　　　// 重载运算符 ->
　　　Obj* operator->() const　
　　　{
　　　　　if(!oc.a[index])
　　　　　{
　　　　　　　　cout << "Zero value";
　　　　　　　　return (Obj*)0;
　　　　　}
　　　　　return oc.a[index];
　　　}
};
　
int main() {
　　　const int sz = 10;
　　　Obj o[sz];
　　　ObjContainer oc;
　　　for(int i = 0; i < sz; i++)
　　　{
　　　　　　　oc.add(&o[i]);
　　　}
　　　SmartPointer sp(oc); // Creazione di un iteratore
　　　do {
　　　　　　sp->f(); // Chiamata a puntatore intelligente
　　　　　　sp->g();
　　　} while(sp++);
　　　return 0;
}

Quando il codice sopra viene compilato ed eseguito, produrrà i seguenti risultati:

10
12
11
13
12
14
13
15
14
16
15
17
16
18
17
19
18
20
19
21

Sovraccarico dell'operatore e funzione C++