parametres templates

Le
AG
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

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;
};

et :

monAlgo<mesTypes> A;

et

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
};

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 ?

Merci d'avance,

AG.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Michael DOUBEZ
Le #308688
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.



monAlgo<monType<N1,N2> > A; // pas possible.


Tu peux faire qq chose comme

template<typename N1, typename N2 >
struct monAlgoType
{
typedef typename monAlgo< monType<N1,N2> > Type;
};


Plutôt que de rajouter autant de type monType<N1,N2> que de réglages
différents dans le template de monAlgo :

template
avec ensuite :

monAlgo

Je ne comprends pas.
Est ce que tu utilise monType<N1,N2> et monType<N3,N4> ... en même temps ?

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;
};

et :

monAlgo<mesTypes> A;

et

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
};


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
Le #309401
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 ...


En fait, je voudrais maintenant avoir :

template< ???? > class monAlgo
{
private:
monType<N1,N2> param1;
monType<N3,N4> param2;
};

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;
};

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
public:
void foo(void);
};

template<class T> void foo(void)
{
param1 = param1 + param2;
}

monAlgo<mesTypes<12,13,14,15> > A;

Ainsi, si j'ai besoin de rajouter un membre dans monAlgo, je peux le
faire sans changer le parametre template de la class monAlgo :

template<int N1, int N2, int N3, int N4> class mesTypes
{
public:
typedef monType<N1,N2> Type1;
typedef monType<N3,N4> Type2;
typedef monType<N1,N4> Type3;
};

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
typename T::Type3 param3;
public:
void foo(void);
};

template<class T> void foo(void)
{
param3 = param1 + param2;
}

Est-ce plus clair ?

AG.


Michael DOUBEZ
Le #309399

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 ...


En fait, je voudrais maintenant avoir :

template< ???? > class monAlgo
{
private:
monType<N1,N2> param1;
monType<N3,N4> param2;
};

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;
};

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
public:
void foo(void);
};

template<class T> void foo(void)
{
param1 = param1 + param2;
}

monAlgo<mesTypes<12,13,14,15> > A;

Ainsi, si j'ai besoin de rajouter un membre dans monAlgo, je peux le
faire sans changer le parametre template de la class monAlgo :

template<int N1, int N2, int N3, int N4> class mesTypes
{
public:
typedef monType<N1,N2> Type1;
typedef monType<N3,N4> Type2;
typedef monType<N1,N4> Type3;
};

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
typename T::Type3 param3;
public:
void foo(void);
};

template<class T> void foo(void)
{
param3 = param1 + param2;
}

Est-ce plus clair ?


Je pense que je vois ce que tu veux faire.

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



Mathias Gaunard
Le #309398

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
};


C'est pas simplement un std::tr1::tuple qu'il te faut ?




AG
Le #309373
"Mathias Gaunard" news: 46951104$0$26320$

template<class T> class monAlgo
{
private:
typename T::Type1 param1;
typename T::Type2 param2;
};


C'est pas simplement un std::tr1::tuple qu'il te faut ?
Je ne connaissais pas, mais j'ai l'impression que c'est un peu

compliqué par rapport à ce que je voulais.


Mathias Gaunard
Le #309368

Je ne connaissais pas, mais j'ai l'impression que c'est un peu compliqué
par rapport à ce que je voulais.


En quoi c'est compliqué ?

Publicité
Poster une réponse
Anonyme