Opérateur () appel de fonction

class chaine{
    int lg;
    char *buf;
    //...
public:
    //...
    chaine operator()(int i,int j)const;
};
chaine chaine::operator()(int i,int j)const{
    assert(i<=j&& i>=0 & j>=0);
    assert(i<lg && j<lg);
    chaine res(buf+i,j-i); // cree une chaine
    return res;
}
void essai(){
   chaine ch1="abcdefgh";
   chaine ch2;
   ch2=ch(2,5);
}

Cet opérateur, peut être surchargé plusieurs fois suivant les types et le nombre de paramètres. Il sert parfois pour définir des itérateurs sur une classe. Supposons par exemple une classe pour des listes :

struct lien{
    lien* suivant;
};
class liste{
friend class liste_iter
    lien *debut;  // debut de liste
    lien *fin;    // fin de la liste
public:
    void inserer(lien *); 
    lien *get();  // retourne l'element en tete
    //...
};

On peut définir un itérateur sur la liste qui maintiendra en plus de la liste un élément courant ; de cette façon on pourra avoir, par exemple plusieurs itérateurs sur la même liste :

class liste_iter{
    liste *lc;   // pointeur sur la liste courante
    lien *courant; //element courant de la liste
public:
    liste_iter(liste& li){  // initialise l'itérateur
       lc=&li;courant=lc->debut;
    }
    lien* operator()(){     // retourne élément suivant
                            // ou 0 
       return courant ? (courant=courant->suivant):0;
    }
}

on pourra alors avoir :

// ...
liste l1;
liste_iter iter(l1);
lien * q;
while(q=iter()){ //... 
}
// ...