Extrait de C++ les paramètres de modèle

Bien que je doute, je suis curieux de savoir si il est possible d'extraire des primitives de type paramètres du modèle à partir d'un type existant, peut-être à l'aide de RTTI.

Par exemple:

typedef std::bitset<16> WordSet;

Serait-il possible d'extraire le numéro 16 dans le code ci-dessus sans coder en dur elle d'ailleurs? Compilateur implémentations spécifiques sont les bienvenus, même si je suis particulièrement intéressé par la g++.

InformationsquelleAutor cdleary | 2008-11-19

c++rtti templates

41

Il n'est pas possible. La manière habituelle, vous faire, c'est ceci:
```
template<int N>
struct foo {
    static const int value = N;
};
```
et pour les types
```
template<typename T>
struct foo {
    typedef T type;
};
```
Vous pouvez y accéder alors que foo<39>::value ou foo<int>::type.

Si vous avez un type particulier, vous pouvez utiliser partielle du modèle de spécialisation:
```
template<typename>
struct steal_it;

template<std::size_t N>
struct steal_it< std::bitset<N> > {
    static const std::size_t value = N;
};
```
Le même principe est possible pour les paramètres de type trop, en effet. Maintenant, vous pouvez passer n'importe quel bitset, comme steal_it< std::bitset<16> >::value (remarque pour utiliser size_t, pas int!). Parce que nous n'avons pas variadic de nombreux modèle paramétrée cependant, nous devons nous limiter nous-mêmes à un certain nombre de paramètre, et répétez l'steal_it spécialisations de modèle pour compter de 1 jusqu'à N. une Autre difficulté consiste à numériser les types qui ont mélangé les paramètres (types et non des types de paramètres). Ce n'est probablement pas évident à résoudre.

Si vous n'avez pas le type, mais seulement un objet, vous pouvez utiliser une astuce, pour toujours obtenir une valeur au moment de la compilation:
```
template<typename T>
char (& getN(T const &) )[steal_it<T>::value];  

int main() {
    std::bitset<16> b;
    sizeof getN(b); //assuming you don't know the type, you can use the object
}
```
L'astuce est de rendre le modèle de fonction auto-déduire le type, puis renvoyer une référence à un tableau de caractères. La fonction n'a pas besoin d'être défini, la seule chose nécessaire est son type.
- Tour de Nice. Une chose cependant, vous commencez par dire à quel point il n'est pas possible, mais alors procéder à montrer qu'il est! 🙂
- Corden: je pense qu'il était en train de dire qu'il n'est pas possible de le faire à l'aide de RTTI
- Richart Corden. Je voulais dire qu'il n'est généralement pas possible de choisir arbitraire de paramètres du modèle. considérez ceci: template<template<class, int> de la classe, de la classe, size_t> class foo; ce truc de ne pas obtenir de leurs types 🙂
InformationsquelleAutor Johannes Schaub - litb

Vous pouvez facilement le faire en C++11 utilisation de l'argument de la déduction et non évaluées contextes (à noter que la démo utilise C++14 variables du modèle de fonction pour des raisons de commodité).

#include <type_traits>
#include <iostream>

template<int>
struct foo {};

template<int arg_N>
struct val {
    static constexpr auto N = arg_N;
};

template<template <int> typename T, int N>
constexpr auto extract(const T<N>&) -> val<N>;

template<typename T>
constexpr auto extract_N = decltype(extract(std::declval<T>()))::N;


int main() {
    std::cout << extract_N<foo<5>>;
}

démo

InformationsquelleAutor Mark Garcia

2

Dans le cas de std::bitset, vous pouvez simplement utiliser le size() fonction de membre:
```
size_t sz = oh_my_word.size();  //sz is now 16
```
Dans le cas général, vous pouvez définir une fonction membre qui retourne la taille d'une manière analogue:
```
template <int N>
class Foo
{
public:
  int size() const { return N; }
};
```
- Je parle de l'extraction de la troisième partie des classes sans size() méthode ou quelque chose de semblable -- l'extraire, il suffit de savoir le type lui-même. La raison étant que je ne veux pas avoir à faire une instance fictive juste pour obtenir la taille de la typedef avais bitset.
- Il n'est pas particulièrement mauvaise pénalité pour bitset, mais il pourrait y avoir d'autres types d'où l'instanciation d'un type dummy est pas souhaitable ou pas pratique.
InformationsquelleAutor Adam Rosenfield
1

Comme indiqué par d'autres réponses, pour std::bitset vous pouvez obtenir la taille à l'aide de la size() fonction de membre, ce qui devrait être le bon choix, mieux que tout autre tour.

Il y a eu plusieurs propositions pour le cas générique, presque semblable à celle que j'ai suggérons ci-dessous, mais je pense que c'est plus simple:
```
template <template<std::size_t> typename T, std::size_t K>
auto extractSize(const T<K>&) {
    return K;
}

int main() {
    std::bitset<6> f1;
    std::bitset<13> f2;
    std::cout << extractSize(f1) << std::endl;
    std::cout << extractSize(f2) << std::endl;
}
```
InformationsquelleAutor Amir Kirsh

Vous devez vous connecter pour publier un commentaire.