Je suis en train de faire une classe "tableau à deux dimensions" (en
gros, une encapsulation d'un "vector< vector<> >") qui implémente les
fonctionnalités suivantes :
1- accès à un élément qui existe, lance une exception s'il n'existe
pas (à la manière de vector<>::at())
2- accès à un élément ; s'il n'existe pas encore, on le crée en
augmentant la taille -- un peu à la façon de map<>::operator[]. Il est
déconseillé d'appeler cette fonction avec (31415927,31415927) comme
paramètres ;-)
L'implémentation de ce genre de trucs ne pose pas vraiment de
problème, ça devrait ressembler à
T& Acces_throw (int x, int y) { return data.at(x).at(y); }
T const& Acces_throw (int x, int y) const { /*idem*/ }
T& Acces_create (int x, int y)
{
if (x>Largeur()) PlusDeColonnes(x);
if (y>Hauteur()) PlusDeLignes(y);
return data.at(x).at(y);
}
La question qui me vient à l'esprit : faut-il "transformer" une de ces
fonctions en opérateur ? [ operator[] avec proxy ou
operator()(int,int) ]
Les créateurs de la STL l'ont fait avec vector<>::operator[] et
vector::at() (deux fonctions qui font à peu près la même chose, l'une
sous forme d'un itérateur, l'autre sous forme "normale"), mais
j'imagine qu'il s'agissait principalement d'un problème de
compatibilité avec les tableaux du C.
En gros, transformer une fonction (laquelle ?) en opérateur
augmenterait la lisibilité en rendant le code utilisateur plus concis,
mais la réduirait en rendant le code utilisateur moins explicite.
Donc, si jamais quelqu'un a un avis là-dessus...
Merci d'avance, et désolé d'avoir été si long.
En plus, vu l'heure, il est possible que ce message contienne pas mal
de conneries :^/
