Je n'arrive pas à faire une classe avec des templates "imbriqués",
c'est-à-dire de ce genre class A<T1 ,T2<T1> >.
Les classes se compilent bien mais arrivé au main je me fait insulté par
le compilo lorsque je crée une instance.
Je suppose qu'il doit y avoir une syntaxe particulière mais je ne la
trouve :(.
Google ne m'a pas beaucoup aidé.
Voici la classe en question et l'instanciation.
## .H ##
template<typename S,template <class S> class A>
class A
{
private : A<S> attribut;
};
## MAIN ##
...
int main()
{
A<int, Truc<int> > obj;
}
## ERREUR COMPIL (g++ 3.3.1 Linux) ##
Main.cc:9: error: type/value mismatch at argument 2 in template
parameter list for `template<class S, template<class S> class A> class
Liste'
Main.cc:9: error: expected a class template, got `Truc<int>'
Alors que la classe Truc est parametré et les instances de Truc<>
fonctionnent sans problèmes.
// Simple template aussi template <class T> Dessin2 { T data; };
// Template template templete <class T, int i, template <class A, int b> class Vec> class Dessin3 { Vec<T, i> data; Vec<T, 2> projectionOnPlane }
int main() { Dessin1<double, 3> d1; // le type de vecteur est fixé Dessin2<blass_vector<double, 3> > d2; // le type est un seul bloc que le template ne peut pas séparer
Dessin3<double, 3, MathVector> d3; // MathVector est donné sans arguments // Dessin3 peut instancier MathVector avec les arguments de son choix }
-- Loïc
LaFleche wrote:
Bonjour,
Je n'arrive pas à faire une classe avec des templates "imbriqués",
c'est-à-dire de ce genre class A<T1 ,T2<T1> >.
Les template template existent, mais ce n'est pas exactement ce que tu
as écrit.
Par exemple :
template <class T, int i> class MathVector
{
//...
};
template <class T, int i> class blas_vector
{
//...
};
// Simple template aussi
template <class T> Dessin2
{
T data;
};
// Template template
templete <class T, int i, template <class A, int b> class Vec>
class Dessin3
{
Vec<T, i> data;
Vec<T, 2> projectionOnPlane
}
int main()
{
Dessin1<double, 3> d1; // le type de vecteur est fixé
Dessin2<blass_vector<double, 3> > d2;
// le type est un seul bloc que le template ne peut pas séparer
Dessin3<double, 3, MathVector> d3;
// MathVector est donné sans arguments
// Dessin3 peut instancier MathVector avec les arguments de son choix
}
// Simple template aussi template <class T> Dessin2 { T data; };
// Template template templete <class T, int i, template <class A, int b> class Vec> class Dessin3 { Vec<T, i> data; Vec<T, 2> projectionOnPlane }
int main() { Dessin1<double, 3> d1; // le type de vecteur est fixé Dessin2<blass_vector<double, 3> > d2; // le type est un seul bloc que le template ne peut pas séparer
Dessin3<double, 3, MathVector> d3; // MathVector est donné sans arguments // Dessin3 peut instancier MathVector avec les arguments de son choix }
-- Loïc
Gabriel Dos Reis
LaFleche writes:
| Bonjour, | | Je n'arrive pas à faire une classe avec des templates "imbriqués", | c'est-à-dire de ce genre class A<T1 ,T2<T1> >. | | Les classes se compilent bien mais arrivé au main je me fait insulté | par le compilo lorsque je crée une instance. | Je suppose qu'il doit y avoir une syntaxe particulière mais je ne la | trouve :(. | Google ne m'a pas beaucoup aidé. | | Voici la classe en question et l'instanciation. | | ## .H ## | template<typename S,template <class S> class A> | class A | { | private : A<S> attribut; | }; | | ## MAIN ## | ... | | int main() | { | A<int, Truc<int> > obj;
A<int, Truc> obj;
-- Gaby
LaFleche <altrash@altern.org> writes:
| Bonjour,
|
| Je n'arrive pas à faire une classe avec des templates "imbriqués",
| c'est-à-dire de ce genre class A<T1 ,T2<T1> >.
|
| Les classes se compilent bien mais arrivé au main je me fait insulté
| par le compilo lorsque je crée une instance.
| Je suppose qu'il doit y avoir une syntaxe particulière mais je ne la
| trouve :(.
| Google ne m'a pas beaucoup aidé.
|
| Voici la classe en question et l'instanciation.
|
| ## .H ##
| template<typename S,template <class S> class A>
| class A
| {
| private : A<S> attribut;
| };
|
| ## MAIN ##
| ...
|
| int main()
| {
| A<int, Truc<int> > obj;
| Bonjour, | | Je n'arrive pas à faire une classe avec des templates "imbriqués", | c'est-à-dire de ce genre class A<T1 ,T2<T1> >. | | Les classes se compilent bien mais arrivé au main je me fait insulté | par le compilo lorsque je crée une instance. | Je suppose qu'il doit y avoir une syntaxe particulière mais je ne la | trouve :(. | Google ne m'a pas beaucoup aidé. | | Voici la classe en question et l'instanciation. | | ## .H ## | template<typename S,template <class S> class A> | class A | { | private : A<S> attribut; | }; | | ## MAIN ## | ... | | int main() | { | A<int, Truc<int> > obj;
A<int, Truc> obj;
-- Gaby
LaFleche
Loïc Joly wrote:
// Template template templete <class T, int i, template <class A, int b> class Vec> class Dessin3 { Vec<T, i> data; Vec<T, 2> projectionOnPlane } Merci Loïc pour ta réponse,
Donc oui c'est bien ce que j'aimerai faire. voici mon code (avec les corrections) : la déclaration des attributs ne plaît pas du tout à g++ (sans les déclarations il compile).
-------- #include <vector> template<class S, template <class X> class A> class G {
private: vector< A < S > > *a; vector<S> *s; ... }; --------
Je suis bien bloqué :'(, d'autant plus que je ne trouve pas de doc là dessus sur le net.
Loïc Joly wrote:
// Template template
templete <class T, int i, template <class A, int b> class Vec>
class Dessin3
{
Vec<T, i> data;
Vec<T, 2> projectionOnPlane
}
Merci Loïc pour ta réponse,
Donc oui c'est bien ce que j'aimerai faire.
voici mon code (avec les corrections) : la déclaration des attributs ne
plaît pas du tout à g++ (sans les déclarations il compile).
--------
#include <vector>
template<class S, template <class X> class A>
class G
{
private:
vector< A < S > > *a;
vector<S> *s;
...
};
--------
Je suis bien bloqué :'(, d'autant plus que je ne trouve pas de doc là
dessus sur le net.
// Template template templete <class T, int i, template <class A, int b> class Vec> class Dessin3 { Vec<T, i> data; Vec<T, 2> projectionOnPlane } Merci Loïc pour ta réponse,
Donc oui c'est bien ce que j'aimerai faire. voici mon code (avec les corrections) : la déclaration des attributs ne plaît pas du tout à g++ (sans les déclarations il compile).
-------- #include <vector> template<class S, template <class X> class A> class G {
private: vector< A < S > > *a; vector<S> *s; ... }; --------
Je suis bien bloqué :'(, d'autant plus que je ne trouve pas de doc là dessus sur le net.
LaFleche
Matthieu Moy wrote:
LaFleche writes:
## .H ## template<typename S,template <class S> class A> class A { private : A<S> attribut; };
Non. A est juste un template à deux arguments. Pas d'imbrication ici.
int main() { A<int, Truc<int> > obj; }
Là, c'est bon.
Si tu définie des fonctions, tu peux faire
int f(int, int); int g(int);
et appeler
f(3, g(4))
Sans le mentionner dans la déclaration.
Oui mais mon but ici c'est justement de controler que le deuxieme argument soit bien une classe templété et que l'argument du template soit le meme type que l'argument du template de G.
Bon ok exemple : A<float, vector<float> > obj; ---> OK A<int, vector<int> > obj; ---> ERREUR A LA COMPIL
Mais je ne suis pas sûr que ce soit possible en c++, ce qui n'arrange pas les choses...
Matthieu Moy wrote:
LaFleche <altrash@altern.org> writes:
## .H ##
template<typename S,template <class S> class A>
class A
{
private : A<S> attribut;
};
Non. A est juste un template à deux arguments. Pas d'imbrication ici.
int main()
{
A<int, Truc<int> > obj;
}
Là, c'est bon.
Si tu définie des fonctions, tu peux faire
int f(int, int);
int g(int);
et appeler
f(3, g(4))
Sans le mentionner dans la déclaration.
Oui mais mon but ici c'est justement de controler que le deuxieme
argument soit bien une classe templété et que l'argument du template
soit le meme type que l'argument du template de G.
Bon ok exemple :
A<float, vector<float> > obj; ---> OK
A<int, vector<int> > obj; ---> ERREUR A LA COMPIL
Mais je ne suis pas sûr que ce soit possible en c++, ce qui n'arrange
pas les choses...
## .H ## template<typename S,template <class S> class A> class A { private : A<S> attribut; };
Non. A est juste un template à deux arguments. Pas d'imbrication ici.
int main() { A<int, Truc<int> > obj; }
Là, c'est bon.
Si tu définie des fonctions, tu peux faire
int f(int, int); int g(int);
et appeler
f(3, g(4))
Sans le mentionner dans la déclaration.
Oui mais mon but ici c'est justement de controler que le deuxieme argument soit bien une classe templété et que l'argument du template soit le meme type que l'argument du template de G.
Bon ok exemple : A<float, vector<float> > obj; ---> OK A<int, vector<int> > obj; ---> ERREUR A LA COMPIL
Mais je ne suis pas sûr que ce soit possible en c++, ce qui n'arrange pas les choses...
LaFleche
Oups j'aui oublié de donner l'e msg d'erreur de g++ :
G.h:15: error: syntax error before `*' token
Oups j'aui oublié de donner l'e msg d'erreur de g++ :
Oups j'aui oublié de donner l'e msg d'erreur de g++ :
G.h:15: error: syntax error before `*' token
Loïc Joly
LaFleche wrote:
Loïc Joly wrote:
// Template template templete <class T, int i, template <class A, int b> class Vec> class Dessin3 { Vec<T, i> data; Vec<T, 2> projectionOnPlane }
Merci Loïc pour ta réponse, Donc oui c'est bien ce que j'aimerai faire. voici mon code (avec les corrections) : la déclaration des attributs ne plaît pas du tout à g++ (sans les déclarations il compile).
-------- #include <vector> template<class S, template <class X> class A> class G {
private: vector< A < S > > *a; vector<S> *s; ... };
La code suivant compile chez moi (dev C++/ gcc3.2) : #include <vector> using namespace std; template<class S, template <class X> class A> class G {
private: vector< A < S > > *a; vector<S> *s; };
int main() { }
J'ai juste ajouté le using namespace... Comme quoi quand on est fixé sur un problème, on ne voit pas trop ce qu'il y a a côté...
-- Loïc
LaFleche wrote:
Loïc Joly wrote:
// Template template
templete <class T, int i, template <class A, int b> class Vec>
class Dessin3
{
Vec<T, i> data;
Vec<T, 2> projectionOnPlane
}
Merci Loïc pour ta réponse,
Donc oui c'est bien ce que j'aimerai faire.
voici mon code (avec les corrections) : la déclaration des attributs ne
plaît pas du tout à g++ (sans les déclarations il compile).
--------
#include <vector>
template<class S, template <class X> class A>
class G
{
private:
vector< A < S > > *a;
vector<S> *s;
...
};
La code suivant compile chez moi (dev C++/ gcc3.2) :
#include <vector>
using namespace std;
template<class S, template <class X> class A>
class G
{
private:
vector< A < S > > *a;
vector<S> *s;
};
int main()
{
}
J'ai juste ajouté le using namespace... Comme quoi quand on est fixé sur
un problème, on ne voit pas trop ce qu'il y a a côté...
// Template template templete <class T, int i, template <class A, int b> class Vec> class Dessin3 { Vec<T, i> data; Vec<T, 2> projectionOnPlane }
Merci Loïc pour ta réponse, Donc oui c'est bien ce que j'aimerai faire. voici mon code (avec les corrections) : la déclaration des attributs ne plaît pas du tout à g++ (sans les déclarations il compile).
-------- #include <vector> template<class S, template <class X> class A> class G {
private: vector< A < S > > *a; vector<S> *s; ... };
La code suivant compile chez moi (dev C++/ gcc3.2) : #include <vector> using namespace std; template<class S, template <class X> class A> class G {
private: vector< A < S > > *a; vector<S> *s; };
int main() { }
J'ai juste ajouté le using namespace... Comme quoi quand on est fixé sur un problème, on ne voit pas trop ce qu'il y a a côté...
