Moins bavard membre const statique privé basé sur un modèle de spécialisation variables

Question

Donc, si je veux me spécialiser:

template<typename T> 
class my_class{ 
     private: 
      static const std::string my_string; 
     }; 

La seule façon que je pouvais faire était par

template<> const std::string my_class<some_type>::my_string = "the string"; 

Disons que j'ai un tas des membres statiques privés et un tas de spécialisations.

Y a-t-il une façon plus propre de faire cela? plus proche de:

my_class<some_type>::my_string = "the string"; 

Answer 1

Une approche est la répartition des étiquettes.

template<class T> struct tag_t{using type=T;}; 
template<class T> constexpr tag_t<T> tag={}; 

auto make_my_string(tag_t<some_type>){return "the string";} 

alors:

template<typename T> 
class my_class{ 
private: 
    static const std::string my_string; 
}; 

template<class T> 
static const std::string my_class<T>::my_string = make_my_string(tag<T>); 

Les frais généraux par type est la suivante:

auto make_my_string(tag_t<some_type>){return "the string";} 

qui est plus propre que l'alternative. Comme un avantage, vous pouvez définir make_my_string dans l'espace de noms adjacent à some_type, et my_class devrait automatiquement le récupérer via ADL.

Comme vous avez une pile de membres const statiques privés, vous pouvez également les mettre tous dans leur propre structure. Ensuite, vous pouvez avoir une fonction pour tous les types pour un type donné, au lieu d'une fonction par membre const static statique.