jeu, 28/06/2012 - 19:02 — @lgorythme
> Parce que la question que je me pose c'est : comment avoir une clsse
> template avec un nombre de paramètres template variables.
En C++11 : il y a un nouveau truc magique qui permet de le faire.
En C++03 : il est possible de le faire en se posant la question différemment.
Un tuple (pour faire simple), c'est juste une struct non nommé.
C'était déjà faisable en C++03 avec les TypeLists et avec C++11, c'est faisable avec les template parameter packs.
Pour les TL, il faut à tout prix lire Modern C++ Design: Generic Programming and Design Patterns Applied d'Andrei
Alexandrescu ( amazon )
Par exemple, j'ai une fonction qui doit retourner un double, un int et un std::string.
Une première méthode est d'utiliser une struct :
| struct s { double d; int i; std::string s; };
s f();
|
On aimerait faire :
struct { double d; int i; std::string s; } f(); // Pas valide en C++
Mais ce n'est pas possible à cause de
FDIS (n3290) §8.3.5 [dcl.fct] ¶9
:
> Types shall not be defined in return or parameter types. […]
Et en plus, les membres de la structure sont nommés là.
Mais il y a mieux, en C++11, on peut faire :
std::tuple<double,int,std::string> f();
Et en C++03 :
cons<double, cons<int, cons<std::string, empty> > > f();
En définissant cons et empty comme :
| struct empty{};
template <typename Head, typename Tail>
struct cons: Tail{ // Version trop simple pour être vrai.
Head val;
};
|
Pour que ça soit joli, on utilisait des macros, ça donnait un truc du genre :
TL3(double, int, std::string) f();
Et donc en fait, le template cons a toujours deux paramètres, c'est juste que ces paramètres sont plus où moins
compliqués. Je l'ai appelé cons comme en lisp pour ceux qui connaissent… Mais sinon, pense à une liste en C :
struct list { int valeur; struct list *suivant; };
… il n'y a que deux éléments mais la liste peut être de
n'importe quelle longueur.
En C++11, la déclaration d'un tuple c'est quelque chose comme :
| template <typename... Types>
struct tuple;
|
Comme définie dans le
FDIS (n3290) §20.4.2 [tuple.tuple]
.
En fait, le principe sera le même qu'en C++03 (on a un membre Head et on hérite du tuple formé du reste).
Le ... pour un template parameter c'est à peu près la même chose qu'un ... pour un function parameter. D'ailleurs c'est
marrant puisque du coup on peut faire suivre un template parameter pack d'une function parameter list, ça donne des
trucs du genre :
void(T......)
mer, 27/06/2012 - 19:01 — @lgorythme
> A quoi sert constexpr ?
Au début des templates en C++, les gens pensait : « Oh cool ! plus besoin de void* dans nos containers ». Et puis
(après leur intégration, c'est ça le plus drole) ils se sont rendu compte que les templates étaient en fait un langage
turing-complet exécuté à la compilation. En gros, ça permet d'utiliser gcc comme un interpréteur (et non compilateur) !
Mais les templates ne sont pas vraiment fait pour ça alors la syntaxe est assez barbare, constexpr permet de faire ça en
moins barbare (mais c'est un mauvais moyen de le définir).
ven, 29/06/2012 - 23:01 — Ekleog
> "Edit epsilon012 : les \< > !" -> Hein ? Depuis quand est-ce que tu
> peux modifier mes messages, toi ? Ou alors je suis schizophrène ? o_Ø
Depuis que je suis vilain organisateur, je peux prendre controle de l'esprit des candidats, la nuit dernière, je t'ai
réveillé sans que tu t'en rendes compte.