Gestion d'un template

Bonjour.

J'apprends le concept de Template, dans le but de simplifier mon code et d'utiliser une class template pour gérer de la même façon différents types d'objets ( il me semble bien que cela peut servir a ca ).

Cependant, quand je tape ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

template < typename T > class OBJECT_Template {   public :   OBJECT_Template () {} ~OBJECT_Template () {}   template < typename Ti > void setObject ( Ti &target ) { std::unique_ptr < T > model ( new T ( target )); _template_vector.push_back ( std::move ( model ) ) ; }   void update () {   for ( std::vector < std::unique_ptr < T > > :: iterator it = _template_vector.begin() ; it != _template_vector.end() ; it ++ ) { ( *it ) -> update() ; } }   private :   std::vector < std::unique_ptr < T > > _template_vector ; };

---

il me dit ceci :

"error:need ' typename ' before ' std::vector < std::unique_ptr < T > > :: iterator ' because ' std::vector < std::unique_ptr < T > > ' is a dependent scope.

Qu'a cela ne tienne, je rajoute ( bêtement ) typename devant vector :

Code:

---

1 2 3 4 5 6

for ( typename std::vector < std::unique_ptr < T > > :: iterator it = _template_vector.begin() ; it != _template_vector.end() ; it ++ ) { ( *it ) -> update() ; }

---

et en effet, ca compile, et le programme fonctionne.

Mais la fonction update de mon objet n'opère pas.

Savez vous d'où cela pourrait provenir ?

Merci si vous pouvez m'aider

Autant pour moi, cela fonctionne. :aie:

En revanche, il y a quelque chose qui me taraude avec les templates : est-il possible de faire une template qui puisse accumulier, par exemple, différents templates : l'idée serait ceci :

Code:

---

1 2 3 4 5 6 7 8

std::vector < TemplateQuiAccumuleDesTemplates < nimporteQuelTemplate?? > > _superTemplate ;   superTemplate.addTemplate ( 45 ) ; superTemplate.addTemplate ( objetDivers ) ; superTemplate.addTemplate ( "salut les copains de developpez" ) ; etc...

---

Bien sur ca na marche pas, car il faut toujours préciser quel objet peut être mis en template. Du coup, ca devient moins intéressant, a moins qu'il y ait une methode pour faire ce genre de choses ?

Citation:

---

Envoyé par mazertys17

Bien sur ca na marche pas, car il faut toujours préciser quel objet peut être mis en template.

---

Non, le mécanisme de déduction des templates permet de ne pas forcément le préciser. Exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <iostream>   struct Test { template <typename T> void print(T const& value) { std::cout << value << std::endl; } };   int main() { Test t; t.print(1); t.print(3.f); t.print("Salut"); return 0; }

---

Par contre, ça implique, dans ton cas d'usage, que tous les objets ajoutés dans la collection soient du même type et donc dérivent d'une classe parente commune (bonne exemple d'usage de l'héritage ici). En l'occurence, la classe parente doit posséder une fonction membre virtuelle (pure ou non) qui s'appelle update.

C'est hors sujet mais pense au ranged-based for loop :

Code:

---

1 2 3 4

for (auto& element : _template_vector) { if (element) element->update() ; }

---

Je suis pas sur d'avoir tout compris, mais ça viendra j'espère, merci pour les liens.

ps : merci jblecanard pour le filon ( sur auto ), ca va éclaircir mon code ! :)

Il y a une chose que j'ai du mal a saisir. Je crée un Template qui fonctionne avec un objet, mais pas un autre, alors qu'il est bâti sur le même model. C'est sur le destructeur de l'objet qu'intervient l'erreur, dès lors que je t'ente d'implémenter le template, avec l'objet en question dans une class. Il me dit : "error: within this context"

avant, il y a des messages d'avertissement, sur le constructeur de ma class template :

"required from 'OBJECT_Template<T>::OBJECT_TEemplate() [with T = OBJECT_HUD]'

j'ai pourtant bien inulde mon "OBJECT_HUD.h"

et enfin il me dit "required from here" au constructeur de mon object pricipale qui est censé contenir la template.
chose étonant, le même template fonctionne avec un autre objet.

Si je vide toutes les fonctions de mon template, pour ne laisser que le constructeur/destructeur, toujours le même problème :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#include "OBJECT_Base.h" #include "OBJECT_HUD.h"   template < typename T > class OBJECT_Template {   public :   OBJECT_Template () {} ~OBJECT_Template () {}   template < typename Ti > void setObject ( Ti &target , float x , float y ) {   }   void initializes () {   }   void update () {   }   bool contiend ( std::string name ) {       return true ; }     std::unique_ptr < T > getObject ( std::string name ) { std::unique_ptr < T > model ( new T );     return std::move ( model ) ; }     private :   std::vector < std::unique_ptr < T > > _template_vector ; };

---

En revanche, si j'enlève l'attribu en private, alors il compile.

J'ai du mal a saisir pourquoi.

Merci si vous pouvez m'aider .

Ma boule de crystal n'est pas parvenue à me montrer le code de Object_hud.

Hello

std::unique_ptr possède la particularité d'avoir besoin du destructeur de l'objet pointé pour être instancié, contrairement à shared_ptr pour qui une forward declaration suffit. Ton problème provient très probablement d'une erreur vis à vis de Object_HUD. Par exemple, le destructeur doit être au minimum public, or la visibilité par défaut des membres d'une classe est privée. Par contre tu pourrais nous donner plus d'info sur les messages d'erreurs que tu as ?

Voici un exemple qui provoque un problème similaire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <memory> #include <vector>   class A { virtual ~A() {}; };   template <typename T> class Accumulator { std::vector<std::unique_ptr<T>> member_; };   int main() { Accumulator<A> acc; return 0; }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/usr/include/c++/4.9/bits/unique_ptr.h: In instantiation of 'void std::default_delete<_Tp>::operator()(_Tp*) const [with _Tp = A]': /usr/include/c++/4.9/bits/unique_ptr.h:236:16: required from 'std::unique_ptr<_Tp, _Dp>::~unique_ptr() [with _Tp = A; _Dp = std::default_delete<A>]' /usr/include/c++/4.9/bits/stl_construct.h:93:7: required from 'void std::_Destroy(_Tp*) [with _Tp = std::unique_ptr<A, std::default_delete<A> >]' /usr/include/c++/4.9/bits/stl_construct.h:103:46: required from 'static void std::_Destroy_aux<<anonymous> >::__destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = std::unique_ptr<A, std::default_delete<A> >*; bool <anonymous> = false]' /usr/include/c++/4.9/bits/stl_construct.h:127:27: required from 'void std::_Destroy(_ForwardIterator, _ForwardIterator) [with _ForwardIterator = std::unique_ptr<A, std::default_delete<A> >*]' /usr/include/c++/4.9/bits/stl_construct.h:151:31: required from 'void std::_Destroy(_ForwardIterator, _ForwardIterator, std::allocator<_T2>&) [with _ForwardIterator = std::unique_ptr<A, std::default_delete<A> >*; _Tp = std::unique_ptr<A, std::default_delete<A> >]' /usr/include/c++/4.9/bits/stl_vector.h:425:30: required from 'std::vector<_Tp, _Alloc>::~vector() [with _Tp = std::unique_ptr<A, std::default_delete<A> >; _Alloc = std::allocator<std::unique_ptr<A, std::default_delete<A> > >]' main.cc:13:29: required from here main.cc:5:11: error: 'virtual A::~A()' is private virtual ~A() {}; ^ In file included from /usr/include/c++/4.9/memory:81:0, from main.cc:1: /usr/include/c++/4.9/bits/unique_ptr.h:76:2: error: within this context delete __ptr;

---

Le message d'erreur est clair dans ce cas : main.cc:5:11: error: 'virtual A::~A()' is private.

Encore un grand merci a jblecanard !!:P

Une lecture de votre réponse et un simple click résoud le problème !

Citation:

---

le destructeur doit être au minimum public

---

J'avais en effet tout simplement oublié de mettre "public" avant le constructeur/destructeur !