Templates - instance passée en paramètre

Bonjour à tous,

Hé bien tout d'abord je voudrais savoir, y a-t-il une raison de ne pas utiliser les templates de cette manière :

Code:

---

1 2 3 4 5 6

class A { public : void truc(); /* ... */ } template <A a> void f() { a.truc(); } // ... A a; f<a>();

---

Ensuite, si cette utilisation ne pose pas de problèmes, je suppose qu'on peut "templatiser" le type du paramètre...
dans le genre de :

Code:

---

1 2	template < template <class T> T t> void f() { }

---

mais cette syntaxe ne compile pas.
Merci de votre temps.

A priori ce code semble bizarre... et peu recommandé même s'il marchait : le compilateur génère une fonction pour chaque valeur "templatizée" utilisée. Imagine ce que ca donne si tu as des milliers ou millions d'instances ! Il vaut bien mieux utiliser des paramètres de fonctions tout simples.

Il y a une raison pour qu'on ne puisse pas faire cela : c'est que ce qui est templatisé doit être connu au moment de la compilation. Lorsque tu écris :

Code:

---

template <A a> void f() { a.truc(); }

---

tu passes une variable comme paramètre template, ce qui n'est pas acceptable par le compilateur.

Je ne comprends pas bien ce que tu cherches à faire avec ce code, mais peut-être est-ce la spécialisation des templates qui t'intéresse ?
http://c.developpez.com/faq/cpp/?pag...specialisation

Pas forcément, justement.
J'voulais juste voir jusqu'ou on pouvait aller.
Mais avec les templates, imaginons un tableau de taille N, dans une class template, ou l'on précise l'entier N à la compilation.
Ce code compilerait (non?) pourtant :

Code:

---

1 2 3 4

int n; cin >> n; Maclass<n> m;

---

Ce qui ne diffère pas fondamentalement du premier code que j'ai mis.
Enfin de toute manière je peux retrouver un comportement semblable à celui que j'ai voulu sans trop de problèmes il me semble.en passant par une structure intermédiaire pour "templatiser" le type, mais bon, rares seront les cas ou j'aurais besoin de passer l'instance en paramètre, car c'est un peu absurde :lol:
Autant faire un

Code:

---

1 2	template <class T> void f(T t)

---

Ce code ne compile pas car n n'est pas constant et non connu à la compilation.

Citation:

---

Ce code compilerait (non?) pourtant :
Code :

int n;cin >> n;Maclass<n> m;

---

Non. n doit être déterminé à la compilation. Un template est instancié statiquement, et le compilateur doit avoir toutes les infos nécessaires pour compiler. S'il compile, tu risque d'avoir un problème...
Notons qu'un paramètre de template ne peut être utilisé en tant que variable comme ici :

Citation:

---

Code :

template <A a> void f() { a.truc(); }

---

et cela est fort heureux, car un paramètre de template est un paramètre de TYPE (en général, d'où le mot clé typename). Notons qu'il peut s'agir aussi d'une constante. Quoi qu'il en soit, ce paramètre doit être connu à la compilation.

Je sais bien. Je voulais simplement tester les limites.

Bonjour,

Je sais que le problème est résolu mais comme personne n'avait répondu à la question suivante :

Citation:

---

Ensuite, si cette utilisation ne pose pas de problèmes, je suppose qu'on peut "templatiser" le type du paramètre...
dans le genre de :

Code :

template < template <class T> T t> void f() { }

---

Tu ne chercherais pas à mettre un paramètre template en tant que paramètre de ton template ? Dans ce cas, de souvenirs, il faut écrire

Code:

---

1 2	template < class T, template <class T> U > void f() {...}

---

La classe T paramètre de ta classe template U doit être connu à la compilation. Tu es donc obligé d'avoir deux paramètres pour ton template mais ce n'est peut-être pas ce que tu veux. Je faisais ça pour des classes templates.

++

Pour la double "templatization", c'est bien de ça que je parlais...
Il me semblait avoir lu cette syntaxe.
Quand à l'instance, c'était juste un test.
Merci!

Pour prendre en paramètre template un template, il suffit de ne pas oublier que ses paramètres templates font partie de son type.

Code:

---

1 2 3 4 5 6 7 8 9 10

// Classe template quelconque template <class T, int I, bool B> class Bidule {};   // Classe pouvant recevoir un Bidule en paramètre template template <template <class, int, bool> class A> class Truc {};   // On pourra écrire : Truc<Bidule> Obj;

---