Je trouve dommage d'être obligé de mettre ces 3 "int" dans
compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations
nécéssaire avec le type des functions.
Je trouve dommage d'être obligé de mettre ces 3 "int" dans compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations nécéssaire avec le type des functions.
Personne n'a une idée pour améliorer ça ?
Très intéressant. Bravo !
"plouf" <plouf79@yahoo.fr> a écrit dans le message de news:
LZLRj.106$yk.36@nntpserver.swip.net...
Bonjour à tous,
J'ai essayé de faire un template qui donne la fonction composée de deux
fonction (sans utilisé de "functor"). Je suis arrivé à ça :
Je trouve dommage d'être obligé de mettre ces 3 "int" dans
compose_fct<int,int,int,square,twice> alors qu'on a toutes les
informations nécéssaire avec le type des functions.
Je trouve dommage d'être obligé de mettre ces 3 "int" dans compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations nécéssaire avec le type des functions.
Personne n'a une idée pour améliorer ça ?
Très intéressant. Bravo !
Michael DOUBEZ
Bonjour à tous,
J'ai essayé de faire un template qui donne la fonction composée de deux fonction (sans utilisé de "functor"). Je suis arrivé à ça : [snip]
int (*sqr_tw)(int) = compose_fct<int,int,int,square,twice>; [snip]
Je trouve dommage d'être obligé de mettre ces 3 "int" dans compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations nécéssaire avec le type des functions.
Personne n'a une idée pour améliorer ça ?
Pas vraiment. Spécialiser sur R(*T)(P) est spécialiser sur une valeur; pour avoir une valeur, on est bien obligé d'avoir un type.
Imagine que square ait plusieurs spécialisations: double square(double) float square(float) int square(int)
Se contenter de: compose_fct<square,twice> ne permettrait pas de choisir la bonne valeur.
-- Michael
Bonjour à tous,
J'ai essayé de faire un template qui donne la fonction composée de
deux fonction (sans utilisé de "functor"). Je suis arrivé à ça :
[snip]
int (*sqr_tw)(int) = compose_fct<int,int,int,square,twice>;
[snip]
Je trouve dommage d'être obligé de mettre ces 3 "int" dans
compose_fct<int,int,int,square,twice> alors qu'on a toutes les
informations nécéssaire avec le type des functions.
Personne n'a une idée pour améliorer ça ?
Pas vraiment. Spécialiser sur R(*T)(P) est spécialiser sur une valeur;
pour avoir une valeur, on est bien obligé d'avoir un type.
Imagine que square ait plusieurs spécialisations:
double square(double)
float square(float)
int square(int)
Se contenter de:
compose_fct<square,twice>
ne permettrait pas de choisir la bonne valeur.
J'ai essayé de faire un template qui donne la fonction composée de deux fonction (sans utilisé de "functor"). Je suis arrivé à ça : [snip]
int (*sqr_tw)(int) = compose_fct<int,int,int,square,twice>; [snip]
Je trouve dommage d'être obligé de mettre ces 3 "int" dans compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations nécéssaire avec le type des functions.
Personne n'a une idée pour améliorer ça ?
Pas vraiment. Spécialiser sur R(*T)(P) est spécialiser sur une valeur; pour avoir une valeur, on est bien obligé d'avoir un type.
Imagine que square ait plusieurs spécialisations: double square(double) float square(float) int square(int)
Se contenter de: compose_fct<square,twice> ne permettrait pas de choisir la bonne valeur.
-- Michael
plouf
...
Pas vraiment. Spécialiser sur R(*T)(P) est spécialiser sur une valeur; pour avoir une valeur, on est bien obligé d'avoir un type.
Imagine que square ait plusieurs spécialisations: double square(double) float square(float) int square(int)
Se contenter de: compose_fct<square,twice> ne permettrait pas de choisir la bonne valeur.
Ah oui, je n'avais pas pensé à ça. C'est donc logique qu'on ne puisse pas simplifier plus. Merci.
Seb
...
Pas vraiment. Spécialiser sur R(*T)(P) est spécialiser sur une valeur;
pour avoir une valeur, on est bien obligé d'avoir un type.
Imagine que square ait plusieurs spécialisations:
double square(double)
float square(float)
int square(int)
Se contenter de:
compose_fct<square,twice>
ne permettrait pas de choisir la bonne valeur.
Ah oui, je n'avais pas pensé à ça. C'est donc logique qu'on ne puisse pas
simplifier plus.
Merci.
Imagine que square ait plusieurs spécialisations: double square(double) float square(float) int square(int)
Mais en l'occurence, on n'en a qu'une. Le compilateur est capable de déduire les types qui vont bien dans un tel cas.
Exemple : le code ci-dessous est parfaitement valide, et cesse de l'être quand on enlève les "//".
int square (int); //double square (double);
template <class Resultat, class Argument> void F (Resultat (*fct) (Argument)) {}
int main() { F (square); }
Fabien LE LEZ
On Tue, 29 Apr 2008 22:58:53 +0200, plouf :
[...]
J'ai bien conscience que le code ci-dessous ne répond pas à la question, mais c'est la seule solution que j'aie trouvé pour ne jamais avoir à écrire les types dans le code client.
int main() { Teste (FoncteurCompose (square, twice)); }
On Tue, 29 Apr 2008 22:58:53 +0200, plouf <plouf79@yahoo.fr>:
[...]
J'ai bien conscience que le code ci-dessous ne répond pas à la
question, mais c'est la seule solution que j'aie trouvé pour ne jamais
avoir à écrire les types dans le code client.
J'ai bien conscience que le code ci-dessous ne répond pas à la question, mais c'est la seule solution que j'aie trouvé pour ne jamais avoir à écrire les types dans le code client.
int main() { Teste (FoncteurCompose (square, twice)); }
Fabien LE LEZ
On Tue, 29 Apr 2008 22:58:53 +0200, plouf :
[...]
J'ai bien conscience que le code ci-dessous ne répond pas à la question, mais c'est la seule solution que j'aie trouvé pour ne jamais avoir à écrire les types dans le code client.
int main() { Teste (FoncteurCompose (square, twice)); }
On Tue, 29 Apr 2008 22:58:53 +0200, plouf <plouf79@yahoo.fr>:
[...]
J'ai bien conscience que le code ci-dessous ne répond pas à la
question, mais c'est la seule solution que j'aie trouvé pour ne jamais
avoir à écrire les types dans le code client.
J'ai bien conscience que le code ci-dessous ne répond pas à la question, mais c'est la seule solution que j'aie trouvé pour ne jamais avoir à écrire les types dans le code client.
int main() { Teste (FoncteurCompose (square, twice)); }
Fabien LE LEZ
On Tue, 29 Apr 2008 22:58:53 +0200, plouf :
Je trouve dommage d'être obligé de mettre ces 3 "int" dans compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations nécéssaire avec le type des functions.
J'ai trouvé le moyen d'éviter de spécifier ces trois "int"... à condition de taper les noms des fonctions deux fois ! C'est le code le plus tordu que j'aie pondu depuis un bout de temps...
/* La fonction finale. Aux noms des identifiants près, il s'agit de ton code. */
/* Ici, on sépare les arguments templates "types" des arguments templates "fonctions". L'idée : puisque les deux fonctions sont des arguments templates, il faut que les trois types soient déjà définis. La seule façon de faire, c'est de mettre "GetF" dans une classe template. */
/* Le compilateur est capable de déduire automatiquement les paramètres template pour une fonction, mais pas pour une classe. On crée donc une fonction "helper" qui crée un objet de type Composeur_t. */
int main() { typedef int (*fonction) (int); fonction f= Composeur(square,twice).GetF<square,twice>(); }
On Tue, 29 Apr 2008 22:58:53 +0200, plouf <plouf79@yahoo.fr>:
Je trouve dommage d'être obligé de mettre ces 3 "int" dans
compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations
nécéssaire avec le type des functions.
J'ai trouvé le moyen d'éviter de spécifier ces trois "int"... à
condition de taper les noms des fonctions deux fois !
C'est le code le plus tordu que j'aie pondu depuis un bout de temps...
/* La fonction finale. Aux noms des identifiants près, il s'agit de
ton code. */
/* Ici, on sépare les arguments templates "types" des arguments
templates "fonctions".
L'idée : puisque les deux fonctions sont des arguments templates, il
faut que les trois types soient déjà définis. La seule façon de faire,
c'est de mettre "GetF" dans une classe template. */
/* Le compilateur est capable de déduire automatiquement les
paramètres template pour une fonction, mais pas pour une classe. On
crée donc une fonction "helper" qui crée un objet de type Composeur_t.
*/
Je trouve dommage d'être obligé de mettre ces 3 "int" dans compose_fct<int,int,int,square,twice> alors qu'on a toutes les informations nécéssaire avec le type des functions.
J'ai trouvé le moyen d'éviter de spécifier ces trois "int"... à condition de taper les noms des fonctions deux fois ! C'est le code le plus tordu que j'aie pondu depuis un bout de temps...
/* La fonction finale. Aux noms des identifiants près, il s'agit de ton code. */
/* Ici, on sépare les arguments templates "types" des arguments templates "fonctions". L'idée : puisque les deux fonctions sont des arguments templates, il faut que les trois types soient déjà définis. La seule façon de faire, c'est de mettre "GetF" dans une classe template. */
/* Le compilateur est capable de déduire automatiquement les paramètres template pour une fonction, mais pas pour une classe. On crée donc une fonction "helper" qui crée un objet de type Composeur_t. */
J'aime bien tes deux méthodes. De mon coté je suis parti un peu sur une autre voix en remplaçant les trois "int" par le type des deux méthodes et en essayant de faire quelque chose qui permette de composer des fonction composée. Je suis arrivé à un truc assez marrant qui permet de "définir" les nouvelles fonction avec des typedef. La syntaxe et horrible et je ne pense pas que j'utiliserais ça un jour dans un vrai programme :-D
void test(int n) { typedef int (* i_i)(int); // int -> int typedef string (* i_s)(int); // int -> string
typedef compose<i_i,i_i>::prm<square,twice> sqr_tw; typedef compose<i_i,i_i>::prm<twice,twice> x4; typedef compose<i_i,i_i>::prm<square,square> sqr_sqr; typedef compose<i_i,i_i>::prm<square,sqr_tw::func> sqr_sqr_tw1; typedef compose<i_i,i_i>::prm<sqr_sqr::func,twice> sqr_sqr_tw2; // On peut utiliser i_i ou "x4::type" si on ne connait pas le type typedef compose<i_i,x4::type>::prm<x4::func,x4::func> x16; typedef compose<i_s,x16::type>::prm<toString,x16::func> x16_str;
J'aime bien tes deux méthodes. De mon coté je suis parti un peu sur une autre
voix en remplaçant les trois "int" par le type des deux méthodes et en essayant
de faire quelque chose qui permette de composer des fonction composée. Je suis
arrivé à un truc assez marrant qui permet de "définir" les nouvelles fonction
avec des typedef. La syntaxe et horrible et je ne pense pas que j'utiliserais ça
un jour dans un vrai programme :-D
void test(int n)
{
typedef int (* i_i)(int); // int -> int
typedef string (* i_s)(int); // int -> string
typedef compose<i_i,i_i>::prm<square,twice> sqr_tw;
typedef compose<i_i,i_i>::prm<twice,twice> x4;
typedef compose<i_i,i_i>::prm<square,square> sqr_sqr;
typedef compose<i_i,i_i>::prm<square,sqr_tw::func> sqr_sqr_tw1;
typedef compose<i_i,i_i>::prm<sqr_sqr::func,twice> sqr_sqr_tw2;
// On peut utiliser i_i ou "x4::type" si on ne connait pas le type
typedef compose<i_i,x4::type>::prm<x4::func,x4::func> x16;
typedef compose<i_s,x16::type>::prm<toString,x16::func> x16_str;
J'aime bien tes deux méthodes. De mon coté je suis parti un peu sur une autre voix en remplaçant les trois "int" par le type des deux méthodes et en essayant de faire quelque chose qui permette de composer des fonction composée. Je suis arrivé à un truc assez marrant qui permet de "définir" les nouvelles fonction avec des typedef. La syntaxe et horrible et je ne pense pas que j'utiliserais ça un jour dans un vrai programme :-D
void test(int n) { typedef int (* i_i)(int); // int -> int typedef string (* i_s)(int); // int -> string
typedef compose<i_i,i_i>::prm<square,twice> sqr_tw; typedef compose<i_i,i_i>::prm<twice,twice> x4; typedef compose<i_i,i_i>::prm<square,square> sqr_sqr; typedef compose<i_i,i_i>::prm<square,sqr_tw::func> sqr_sqr_tw1; typedef compose<i_i,i_i>::prm<sqr_sqr::func,twice> sqr_sqr_tw2; // On peut utiliser i_i ou "x4::type" si on ne connait pas le type typedef compose<i_i,x4::type>::prm<x4::func,x4::func> x16; typedef compose<i_s,x16::type>::prm<toString,x16::func> x16_str;