Vérifier à la compilation si un type donné est « comparable »

Il peut arriver que nous souhaitions écrire des programmes utilisant des types devant supporter un certain nombre d'opérations, et qu'il soit désirable à la compilation de vérifier le support des opérations en question pour ces types, sans toutefois qu'on veuille nécessairement instancier ces types.

Par exemple, présumons qu'un programme ait besoin que les types qu'il manipule soient comparables, au sens où on doit pouvoir leur appliquer certains opérateurs relationnels (nous vérifierons le support de < et de <= ici, mais la liste pourrait être aussi longue ou aussi courte que nécessaire).

Rédigeons un tel test. Imaginons la classe Comparable, un template applicable à un type T :

• Elle contient une méthode de classe nommée contraintes(T,T) qui prend en paramètre deux instances de T et tente de leur appliquer une série d'opérations (celles dont on souhaite valider l'existence), et
• Elle contient un constructeur par défaut, qui n'appelle pas contraintes(T,T) mais qui en prend l'adresse dans une variable temporaire. Ceci est fait parce que le compilateur C++ ne génère le code d'un template que si celui-ci est utilisé; nous ne voulons pas appeler la méthode, mais nous voulons que le compilateur en génère le code

template <typename T>
   class Comparable
   {
      //
      // contraintes(T,T) doit être une méthode de classe
      // (static), pour des raisons qui deviennent claires
      // dans le constructeur de Comparable<T> (plus bas)
      //
      static void contraintes(T a, T b)
      {
         //
         // solliciter les opérations dont on veut tester le
         // support pour le type T. Cette fonction ne sera
         // pas créée tant que le compilateur ne lui reconnaîtra
         // pas la chance de servir
         //
         (void)(a < b);  // operator<(T,T)  existe-t-il?
         (void)(a <= b); // operator<=(T,T) existe-t-il?
      }
   public:
      Comparable()
      {
         //
         // prendre un pointeur sur la méthode contraintes(T,T);
         // on n'appelle pas la méthode, mais en prenant son
         // adresse on force le compilateur à générer son code
         // pour des paramètres de type T
         //
         void (*p)(T,T) = contraintes;
      }
   };

Pourquoi cet artifice technique? Pour que des erreurs à la compilation soient détectées si les opérations tentées dans la méthode contraintes(T,T) ne sont pas supportées sur le type T.

Par exemple, instancier un Comparable<int> réussira parce que les opérations < et <= existent pour le type int, instancier un Comparable<X> pour une classe X quelconque ne supportant pas < ou <= échouera dès la compilation.

Le programme principal montre bien la force de la technique :

• Chaque instance de Comparable est créée pour un type donné
• On tente d'y créer des instances de Comparable pour trois types effectivement comparables (int, std::string et TiteSomme) de même que pour un type qui ne l'est pas (Incomparable)
• Si seulement des instances de Comparable y sont créées pour des types effectivement comparables, alors le programme compile sans heurts et sans instancier aucun de ces types. Ceci peut être important si certaines de ces types ont, dans leurs constructeurs, des opérations qu'on voudrait éviter (accès à une BD, par exemple) à moins que cela ne soit nécessaire
• Si, comme c'est le cas dans notre programme de test, on cherche à créer un Comparable appliqué à un type qui n'est pas comparable selon nos règles, alors le programme nom compilera pas (et un bon compilateur nous indiquera même la ou les opérations qui, dans la méthode Comparable<T>::contraintes(T,T), font en sorte d'empêcher la compilation). Encore une fois, évidemment, aucune instance du type testé ne sera réellement instanciée

La beauté ici est que instancier un Comparable<T> ne crée aucun T, mais valide quand même à la compilation une série arbitrairement longue et complexe d'opérations sur T.

#include "Comparable.h" // classe Comparable ci-dessus
#include <string>       // toute std::string supporte < et <=
// La classe Incomparable n'est pas Comparable au sens entendu
// ici: elle ne supporte pas les opérateurs < et <=
class Incomparable { };

// La classe TiteSomme est comparable au sens entendu ici...
class TiteSomme
{
   const int x_, y_;
   int x() const
      { return x_; }
   int y() const
      { return y_; }
public:
   TiteSomme(const int x, const int y)
      : x_(x), y_(y)
   {
   }
   int valeur() const
      { return x_ + y_; }
   bool operator< (const TiteSomme &ts) const
      { return valeur() < ts.valeur(); }
   bool operator<= (const TiteSomme &ts) const
      { return valeur() <= ts.valeur(); }
   bool operator> (const TiteSomme &ts) const
      { return valeur() > ts.valeur(); }
   bool operator>=(const TiteSomme &ts) const
      { return valeur() >= ts.valeur(); }
   bool operator==(const TiteSomme &ts) const
      { return valeur() == ts.valeur(); }
   bool operator!=(const TiteSomme &ts) const
      { return valeur() != ts.valeur(); }
};

int main() {
   Comparable<int> c0;          // Ok; int est Comparable ...
   Comparable<std::string> c1;  // Ok ...
   Comparable<Incomparable> s3; // Erreur!!!
   Comparable<TiteSomme> s4;    // Ok...
}

Le secret de la technique repose sur deux pivots :

• Utiliser un template, pour que le compilateur soit en charge et qu'on puisse s'exprimer en termes méta (parler d'opérations et de types en tant qu'opérations et en tant que types, de manière abstraite), et
• Assurer l'existence (l'instanciation) d'une fonction applicable sur un type donné et faire valider par le compilateur un ensemble de contraintes sur ce type sans jamais appeler la fonction en question. La généricité des templates nous force pour ce faire à saisir l'adresse de la fonction servant à faire les tests, ce qui en assure la création sans qu'on ait à l'invoquer

On s'en doute, cette technique est d'une utilité restreinte si on la prend seule. Elle devient extrêmement utile dans la conception de bibliothèques ou de classes génériques, par contre, là où la validation de contraintes à la compilation devient un critère d'efficacité.