Opérateur -> d'accès

x->m correspond à (x.operator->())->m, il doit donc retourner quelque chose sur lequel l'opérateur -> s'applique (un pointeur). Il s'agit d'un opérateur postfixe unaire.

Il peut permettre d'obtenir des pointeurs ``intelligents'' (smart pointer) qui font plus que retourner l'objet pointé.

Il paraît utile de maintenir la cohérence entre les opérateurs surchargés et leur usage non surchargé ; par exemple, si on surcharge l'opérateur -> , il semble aussi raisonnable de surcharger de façon cohérente les autres opérateurs associés en C++ aux pointeurs, comme * et []. De même, une surcharge de + devrait aller de paire avec une surcharge des opérateurs += et ++.

Exemple : dans cet exemple on définit une classe ptr_tab de pointeurs qui évoluent dans des tableaux avec vérification de non débordement.

#include <stdlib.h>
template <class T>
class ptr_tab{
    T * actuel;
    T * debut;
    T * fin; 
    int est_ok(){
        return actuel<fin && actuel>=debut;
    }
    void erreur_intervale(){
        // devrait générer une exception
        cerr<<"erreur hors zone\n";
        exit(0);
    }
        
public:
    ptr_tab(T *s, size_t nelem){
        actuel=debut=s; fin=debut+nelem;}
    ptr_tab(T *s,size_t nelem,size_t dep){
        debut=s; fin=debut+nelem; actuel=s+dep;}
    T operator*(){
        if(!est_ok())erreur_intervale();
        return *actuel;}
    T* operator->(){
        if(!est_ok())erreur_intervale();
        return actuel;}
    T operator[](int i){ 
        if(actuel+i<fin&&actuel+i>=debut)erreur_intervale();
        return *(actuel+i);}   
    T* operator++(){
        actuel +=1;
        if(!est_ok())erreur_intervale();
        return actuel;
    }
    T* operator++(int){
        if(!est_ok())erreur_intervale();
        return actuel++;
    }
    T* operator--(int){
        if(!est_ok())erreur_intervale();
        return actuel--;
    }
    T* operator--(){
        actuel -= 1;
        if(!est_ok())erreur_intervale();
        return actuel;
    }
    int n_elem_fin(){       // retourne le nombre d'elem avant la fin
        return fin-actuel;
    }
    int n_elem_debut(){     // retourne le nombre d'elem depuis le fin
        return actuel-debut;
    }
};

struct couple{int i,j;
    istream & lire(istream& is){
        is>>i>>j;
        return is;
    }
    ostream & ecrire(ostream& os)const{
        os<<"("<<i<<","<<j<<")\n";
        return os;
    };
};
ostream & operator<<(ostream& os, const couple& c){
    return c.ecrire(os);
}
istream & operator>>(istream& is, couple& c){
    return c.lire(is);
}

void main()
{   
    couple t[4];
    ptr_tab<couple> p(t,4),q(t,4);
    while(p.n_elem_fin()>0){cin>>*p++;}
    while(p.n_elem_debut()>0){cout<<(--p)->i<<" ";}
}