J'ai commencé un projet avec comme argument template, le type des
données sur lequelles je travaillais. Jusqu'ici tout va bien. J'avais
en tête d'utiliser cet algorithme sur des double ou des int.
template<class T> class monAlgo
{
private:
T param1;
T param2;
};
Chemin faisant, j'aimerais maintenant avoir un type plus fins que int.
Ce nouveau type que je voudrais utiliser est une classe à lui tout
seul, qui possède elle même plusieurs parametres templates.
template<class N1, class N2> class monType;
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des
parametres N1 et N2 différents suivant les endroits, je ne pas
simplement donner monType comme argument du template de monAlgo
monAlgo<monType<N1,N2> > A; // pas possible.
Plutôt que de rajouter autant de type monType<N1,N2> que de réglages
différents dans le template de monAlgo :
template<class Type1, class Type2, etc...> class monAlgo;
avec ensuite :
monAlgo<monType<N1,N2>,monType<N3,N4>,etc...> A;
ce qui exige de re-écrire pas mal de code, je pensais faire quelque
chose du genre :
template<class N1, class N2, class N3, class N4> class mesTypes
{
typedef monType<N1,N2> Type1;
typedef monType<N3,N4> Type2;
};
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Michael DOUBEZ
Bonjour à tous,
J'ai commencé un projet avec comme argument template, le type des données sur lequelles je travaillais. Jusqu'ici tout va bien. J'avais en tête d'utiliser cet algorithme sur des double ou des int.
template<class T> class monAlgo { private: T param1; T param2; };
Chemin faisant, j'aimerais maintenant avoir un type plus fins que int. Ce nouveau type que je voudrais utiliser est une classe à lui tout seul, qui possède elle même plusieurs parametres templates.
template<class N1, class N2> class monType;
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres N1 et N2 différents suivant les endroits, je ne pas simplement donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
Mais ce qui m'étonne, c'est que tu puisse changer les types dans monType. Ton algo n'est peux être pas si générique que ça.
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des doubles.
Je pense que cela nécessite moins de code à re-écrire, et est plus flexible. Est-ce l'usage, et si non comment feriez vous ?
Je ne comprends pas ce que tu veux faire.
Michael
Bonjour à tous,
J'ai commencé un projet avec comme argument template, le type des
données sur lequelles je travaillais. Jusqu'ici tout va bien. J'avais en
tête d'utiliser cet algorithme sur des double ou des int.
template<class T> class monAlgo
{
private:
T param1;
T param2;
};
Chemin faisant, j'aimerais maintenant avoir un type plus fins que int.
Ce nouveau type que je voudrais utiliser est une classe à lui tout seul,
qui possède elle même plusieurs parametres templates.
template<class N1, class N2> class monType;
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres
N1 et N2 différents suivant les endroits, je ne pas simplement donner
monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
Mais ce qui m'étonne, c'est que tu puisse changer les types dans
monType. Ton algo n'est peux être pas si générique que ça.
J'ai commencé un projet avec comme argument template, le type des données sur lequelles je travaillais. Jusqu'ici tout va bien. J'avais en tête d'utiliser cet algorithme sur des double ou des int.
template<class T> class monAlgo { private: T param1; T param2; };
Chemin faisant, j'aimerais maintenant avoir un type plus fins que int. Ce nouveau type que je voudrais utiliser est une classe à lui tout seul, qui possède elle même plusieurs parametres templates.
template<class N1, class N2> class monType;
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres N1 et N2 différents suivant les endroits, je ne pas simplement donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
Mais ce qui m'étonne, c'est que tu puisse changer les types dans monType. Ton algo n'est peux être pas si générique que ça.
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des doubles.
Je pense que cela nécessite moins de code à re-écrire, et est plus flexible. Est-ce l'usage, et si non comment feriez vous ?
Je ne comprends pas ce que tu veux faire.
Michael
AG
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres N1 et N2 différents suivant les endroits, je ne pas simplement donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
param1 n'est plus un int ou un double. Il n'est même plus du même type que param2.
je n'ai pas l'impression que cela soit compatible avec template< template < typename, typename> class T> class monAlgo ...
si ?
Mais ce qui m'étonne, c'est que tu puisses changer les types dans monType. Ton algo n'est peux être pas si générique que ça.
ok, en vrai c'est plutôt :
template<int N1, int N2> class monType;
mais ça revient au même.
Je ne comprends pas. Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même temps ? oui
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des doubles. oui, il fonctionne avec des monType<N1,N2> ET des monType<N3,N4> en
même temps.
(Et un parametrage spécial de monType< , > avec le N1 et le N2 qui vont bien me fait retrouver soit un int, soit un double).
On peut penser par exemple que monType<N1,N2> est un modèle de d'entier, avec N1 bits, et N2 pour indiquer si c'est signé ou non. Dans mon algorithme, là ou au départ j'utilisais des int partout, je voudrais utiliser des monType<N1,N2> à certains endroits, des monType<N3,N4> à d'autres, et peut être des monType<N5,N6> encore ailleurs. Je voudrais avoir le moins de code à rajouter lorsque je décide qu'a tel endroit dans monAlgo, je dois utiliser un nouveau monType< , >.
ce que j'ai trouvé comme idée était donc de faire :
template<int X, int Y> class monType;
template<int N1, int N2, int N3> class mesTypes { public: typedef monType<N1,N2> Type1; typedef monType<N1+3,N3> Type2; };
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des
parametres
N1 et N2 différents suivant les endroits, je ne pas simplement
donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
param1 n'est plus un int ou un double. Il n'est même plus du même type
que param2.
je n'ai pas l'impression que cela soit compatible avec
template< template < typename, typename> class T> class monAlgo ...
si ?
Mais ce qui m'étonne, c'est que tu puisses changer les types dans
monType. Ton algo n'est peux être pas si générique que ça.
ok, en vrai c'est plutôt :
template<int N1, int N2> class monType;
mais ça revient au même.
Je ne comprends pas.
Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même
temps ?
oui
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des
doubles.
oui, il fonctionne avec des monType<N1,N2> ET des monType<N3,N4> en
même temps.
(Et un parametrage spécial de monType< , > avec le N1 et le N2 qui
vont bien me fait retrouver soit un int, soit un double).
On peut penser par exemple que monType<N1,N2> est un modèle de
d'entier, avec N1 bits, et N2 pour indiquer si c'est signé ou non.
Dans mon algorithme, là ou au départ j'utilisais des int partout, je
voudrais utiliser des monType<N1,N2> à certains endroits, des
monType<N3,N4> à d'autres, et peut être des monType<N5,N6> encore
ailleurs. Je voudrais avoir le moins de code à rajouter lorsque je
décide qu'a tel endroit dans monAlgo, je dois utiliser un nouveau
monType< , >.
ce que j'ai trouvé comme idée était donc de faire :
template<int X, int Y> class monType;
template<int N1, int N2, int N3> class mesTypes
{
public:
typedef monType<N1,N2> Type1;
typedef monType<N1+3,N3> Type2;
};
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres N1 et N2 différents suivant les endroits, je ne pas simplement donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
param1 n'est plus un int ou un double. Il n'est même plus du même type que param2.
je n'ai pas l'impression que cela soit compatible avec template< template < typename, typename> class T> class monAlgo ...
si ?
Mais ce qui m'étonne, c'est que tu puisses changer les types dans monType. Ton algo n'est peux être pas si générique que ça.
ok, en vrai c'est plutôt :
template<int N1, int N2> class monType;
mais ça revient au même.
Je ne comprends pas. Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même temps ? oui
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des doubles. oui, il fonctionne avec des monType<N1,N2> ET des monType<N3,N4> en
même temps.
(Et un parametrage spécial de monType< , > avec le N1 et le N2 qui vont bien me fait retrouver soit un int, soit un double).
On peut penser par exemple que monType<N1,N2> est un modèle de d'entier, avec N1 bits, et N2 pour indiquer si c'est signé ou non. Dans mon algorithme, là ou au départ j'utilisais des int partout, je voudrais utiliser des monType<N1,N2> à certains endroits, des monType<N3,N4> à d'autres, et peut être des monType<N5,N6> encore ailleurs. Je voudrais avoir le moins de code à rajouter lorsque je décide qu'a tel endroit dans monAlgo, je dois utiliser un nouveau monType< , >.
ce que j'ai trouvé comme idée était donc de faire :
template<int X, int Y> class monType;
template<int N1, int N2, int N3> class mesTypes { public: typedef monType<N1,N2> Type1; typedef monType<N1+3,N3> Type2; };
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres N1 et N2 différents suivant les endroits, je ne pas simplement donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
param1 n'est plus un int ou un double. Il n'est même plus du même type que param2.
je n'ai pas l'impression que cela soit compatible avec template< template < typename, typename> class T> class monAlgo ...
si ?
Ca depends, si N1,N2,N3,N4 sont connus et que la genericité se fait sur monType qui prend deux type en parametre, alors oui.
monAlgo<monType>::param1 est de type monType<N1,N2>; monAlgo<monType>::param2 est de type monType<N3,N4>;
Mais ce qui m'étonne, c'est que tu puisses changer les types dans monType. Ton algo n'est peux être pas si générique que ça.
ok, en vrai c'est plutôt :
template<int N1, int N2> class monType;
mais ça revient au même.
Je ne comprends pas. Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même temps ? oui
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des doubles. oui, il fonctionne avec des monType<N1,N2> ET des monType<N3,N4> en même
temps.
(Et un parametrage spécial de monType< , > avec le N1 et le N2 qui vont bien me fait retrouver soit un int, soit un double).
On peut penser par exemple que monType<N1,N2> est un modèle de d'entier, avec N1 bits, et N2 pour indiquer si c'est signé ou non. Dans mon algorithme, là ou au départ j'utilisais des int partout, je voudrais utiliser des monType<N1,N2> à certains endroits, des monType<N3,N4> à d'autres, et peut être des monType<N5,N6> encore ailleurs. Je voudrais avoir le moins de code à rajouter lorsque je décide qu'a tel endroit dans monAlgo, je dois utiliser un nouveau monType< , >.
ce que j'ai trouvé comme idée était donc de faire :
template<int X, int Y> class monType;
template<int N1, int N2, int N3> class mesTypes { public: typedef monType<N1,N2> Type1; typedef monType<N1+3,N3> Type2; };
En fait, tu aurais: template<typename T1, typename T2> class monAlgo { private: T1 param1; T2 param2; public: void foo(void); };
Mais tu voudrais que T1 et T2 soient des types speciaux pour ton algo template<int N1, int N2, int N3, int N4> typedef monAlgo< monType<N1,N2> , monType<N3,N4> > monAlgoType4;
Ou eventuellement generaliser sur monType: template<template <int,int> class Gentype ,int N1, int N2, int N3, int N4> typedef monAlgo< Gentype <N1,N2> , Gentype <N3,N4> > monAlgoGentype4;
Michael
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres
N1 et N2 différents suivant les endroits, je ne pas simplement donner
monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
param1 n'est plus un int ou un double. Il n'est même plus du même type
que param2.
je n'ai pas l'impression que cela soit compatible avec
template< template < typename, typename> class T> class monAlgo ...
si ?
Ca depends, si N1,N2,N3,N4 sont connus et que la genericité se fait sur
monType qui prend deux type en parametre, alors oui.
monAlgo<monType>::param1 est de type monType<N1,N2>;
monAlgo<monType>::param2 est de type monType<N3,N4>;
Mais ce qui m'étonne, c'est que tu puisses changer les types dans
monType. Ton algo n'est peux être pas si générique que ça.
ok, en vrai c'est plutôt :
template<int N1, int N2> class monType;
mais ça revient au même.
Je ne comprends pas.
Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même
temps ?
oui
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des
doubles.
oui, il fonctionne avec des monType<N1,N2> ET des monType<N3,N4> en même
temps.
(Et un parametrage spécial de monType< , > avec le N1 et le N2 qui vont
bien me fait retrouver soit un int, soit un double).
On peut penser par exemple que monType<N1,N2> est un modèle de d'entier,
avec N1 bits, et N2 pour indiquer si c'est signé ou non.
Dans mon algorithme, là ou au départ j'utilisais des int partout, je
voudrais utiliser des monType<N1,N2> à certains endroits, des
monType<N3,N4> à d'autres, et peut être des monType<N5,N6> encore
ailleurs. Je voudrais avoir le moins de code à rajouter lorsque je
décide qu'a tel endroit dans monAlgo, je dois utiliser un nouveau
monType< , >.
ce que j'ai trouvé comme idée était donc de faire :
template<int X, int Y> class monType;
template<int N1, int N2, int N3> class mesTypes
{
public:
typedef monType<N1,N2> Type1;
typedef monType<N1+3,N3> Type2;
};
En fait, tu aurais:
template<typename T1, typename T2> class monAlgo
{
private:
T1 param1;
T2 param2;
public:
void foo(void);
};
Mais tu voudrais que T1 et T2 soient des types speciaux pour ton algo
template<int N1, int N2, int N3, int N4>
typedef monAlgo< monType<N1,N2> , monType<N3,N4> > monAlgoType4;
Ou eventuellement generaliser sur monType:
template<template <int,int> class Gentype ,int N1, int N2, int N3, int N4>
typedef monAlgo< Gentype <N1,N2> , Gentype <N3,N4> > monAlgoGentype4;
Vu que dans monAlgo, je vais utiliser monType<N1,N2> avec des parametres N1 et N2 différents suivant les endroits, je ne pas simplement donner monType comme argument du template de monAlgo.
Pourquoi pas ?
template< template <typename,typename> class T > class monAlgo ...
param1 n'est plus un int ou un double. Il n'est même plus du même type que param2.
je n'ai pas l'impression que cela soit compatible avec template< template < typename, typename> class T> class monAlgo ...
si ?
Ca depends, si N1,N2,N3,N4 sont connus et que la genericité se fait sur monType qui prend deux type en parametre, alors oui.
monAlgo<monType>::param1 est de type monType<N1,N2>; monAlgo<monType>::param2 est de type monType<N3,N4>;
Mais ce qui m'étonne, c'est que tu puisses changer les types dans monType. Ton algo n'est peux être pas si générique que ça.
ok, en vrai c'est plutôt :
template<int N1, int N2> class monType;
mais ça revient au même.
Je ne comprends pas. Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même temps ? oui
Ce quit veux dire que monAlgo ne fonctionne plus avec des int et des doubles. oui, il fonctionne avec des monType<N1,N2> ET des monType<N3,N4> en même
temps.
(Et un parametrage spécial de monType< , > avec le N1 et le N2 qui vont bien me fait retrouver soit un int, soit un double).
On peut penser par exemple que monType<N1,N2> est un modèle de d'entier, avec N1 bits, et N2 pour indiquer si c'est signé ou non. Dans mon algorithme, là ou au départ j'utilisais des int partout, je voudrais utiliser des monType<N1,N2> à certains endroits, des monType<N3,N4> à d'autres, et peut être des monType<N5,N6> encore ailleurs. Je voudrais avoir le moins de code à rajouter lorsque je décide qu'a tel endroit dans monAlgo, je dois utiliser un nouveau monType< , >.
ce que j'ai trouvé comme idée était donc de faire :
template<int X, int Y> class monType;
template<int N1, int N2, int N3> class mesTypes { public: typedef monType<N1,N2> Type1; typedef monType<N1+3,N3> Type2; };
En fait, tu aurais: template<typename T1, typename T2> class monAlgo { private: T1 param1; T2 param2; public: void foo(void); };
Mais tu voudrais que T1 et T2 soient des types speciaux pour ton algo template<int N1, int N2, int N3, int N4> typedef monAlgo< monType<N1,N2> , monType<N3,N4> > monAlgoType4;
Ou eventuellement generaliser sur monType: template<template <int,int> class Gentype ,int N1, int N2, int N3, int N4> typedef monAlgo< Gentype <N1,N2> , Gentype <N3,N4> > monAlgoGentype4;
