Contournement de la spécialisation du modèle

Supposons que je sois un utilisateur d’une bibliothèque de modèles spécifiques ( CTL ) qui définit un modèle, nommé par exemple Hector

 template  class Hector {...}; 

Et dans sa documentation, il donne de nombreuses garanties sur le comportement du modèle Hector . Mais alors, il définit également une spécialisation pour un certain type Cool

 template  class Hector {....}; 

Le but de la spécialisation est une implémentation plus optimisée de Hector , mais malheureusement, en raison de cette optimisation, de nombreuses garanties de Hector sont violées.

Actuellement, je n’ai vraiment pas besoin de l’optimisation, je préfère conserver toutes les garanties de Hector . Est-ce que je pourrais, sans changer le code de la bibliothèque ( CTL est une bibliothèque hautement respectable, vous savez), contourner la spécialisation? De toute façon? Peut-être écrire une sorte de cape? N’importe quoi? Je veux juste que le compilateur génère du code pour Hector de manière normale et non optimisée, avec toutes les garanties.

Êtes-vous en mesure d’utiliser le modèle associé Reque qui ne possède pas la spécialisation indésirable? Sinon, je pense que vous devriez créer un wrapper pour Cool afin que la spécialisation ne soit pas utilisée.

Vous pouvez envelopper cool dans un type factice pour empêcher le modèle de le spécialiser.

Non. Et même si cela peut être fait de manière ésotérique, non. Les fonctionnalités de contournement de la langue devraient déclencher une alarme.

Vous devez envelopper la valeur ou utiliser un type différent comme char au lieu de bool (ils se comportent de la même façon), donnant std::vector au lieu de std::vector .

Voici un petit déguiseur générique:

 template  struct Drool { Drool(T d) : b(d) { } inline operator T() const { return b; } inline Drool & operator=(T d) { b = d; return *this; } private: T b; }; 

Maintenant, vous pouvez dire Hector> .


Version améliorée selon Xeo:

 template  struct Drool { Drool(const T & d) : b(d) { } Drool(Drool && o) = default; inline operator const T & () const { return b; } inline operator T & () { return b; } private: T b; }; 
  1. Ouvrez la mise en œuvre standard certaine
  2. Ctrl + A
  3. Ctrl + C
  4. Créez un nouveau fichier appelé "my_hector.h"
  5. Ctrl + V
  6. Supprimer la spécialisation
  7. Recherchez et remplacez #include par #include "my_hector.h"
    [Modifier pour @Xeo ;-)]
  8. Renommez les identificateurs commençant par deux traits de soulignement principaux suivis d’une lettre minuscule, et tous les identificateurs commençant par un trait de soulignement principal suivi d’une lettre majuscule.