Question d'élégance avec les templates.

Bonsoir,

J'ai un petit soucis dans la réalisation d'un gestionnaire de ressources.
J'ai crée un singleton CRessourcesManager qui charge des ressources depuis le disque avec une méthode :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class T> QSharedPointer<T> load<T>(QString filename){ QListIterator it(m_loaders); while(it.hasNext()){ IRessourcesLoader loader = it.next(); if(loader.isValid<T>()){ return loader.load<T>(filename); } } }

---

IRessourcesLoader est une classe interface qui doit implémenter le chargement d'un type de données.
Donc pour chaque implémentation de IRessourcesLoader ma méthode doit vérifier si le loader est abilité à charger le type en question.
J'aimerai conserver la possibilité d'écrire n'importe qu'elle implémentation de IRessourcesLoader et de simplement avoir à l'ajouter à CRessourcesManager avant d'apeller la méthode load avec le type attendu.

Existe-t-il une méthode plus élégante ? Que d'utiliser :

Code:

---

1 2 3 4

if(loader.isValid<T>()){ return loader.load<T>(filename); }

---

Merci

isValid() fait quoi?

Cette méthode est sensé vérifier la compatibilité entre le type demandé et le type géré par l'implémentation de IRessourcesLoader.

Je crois avoir trouvé ce que je cherchais :
http://loulou.developpez.com/tutorie...eur3d/partie4/
Il est vraiment incroyable ce mec xD, je trouve son code presque mystique parfois...

Merci

ca serait encore mieux sans Singleton :D

Salut,
Présentation des classes de Traits et de Politiques en C++ par Alp Mestan

Sur le singleton : Etes-vous atteint de Singletonite ?

Je confirme : préfère les traits au code proposé par loulou. Le code de loulou est sympathique, mais il n'est pas extensible. Hors, tu vas vouloir rajouter des loaders, et peut-être permettre à tes utilisateurs de rajouter des loaders - et eux ne peuvent pas modifier ton code.

Les traits, du fait qu'ils sont spécialisable à volonté, permettent au code client d'étendre le code de la librairie sans avoir à le modifier.

Citation:

---

Envoyé par Joel F

ca serait encore mieux sans Singleton :D

---

Et bien tu vois, j'ai eu l'occasion d'y réfléchir assez intensivement par le passé, et dans ce cas précis (Ressource manager pour un jeux), c'est une des rares fois où j'ai pu justifier un singleton (et pourtant je les ai en horreur).

Super, merci les classes de politiques c'est exactement ce que je cherchais, mais je savais pas que ça existé !
Rassurez moi c'est quand même un concept relativement avancé du c++ non ? Je dois m'y reprendre à plusieurs fois avant de saisir les fonctionnements expliqués dans les liens...

Pour ce qui est du singleton du gestionnaire de ressources, je n'ai aucun intérêt à avoir plusieurs instances d'une classe qui vise à centraliser la gestion de la mémoire et plus précisément à limiter les chargements depuis le disque... Donc il me semble qu'un singleton est justifié dans ce cas.

Le singleton ne sert pas qu'a assurer l'uncité d'une instance, il vise à fournir un point d'accés global à une instance, or (et il me semble que c'est expliqué dans l'article d'Emmanuel Deloget), il est souvent possible de centraliser dans une portion restreinte de code l'utilisation de ton manager (avec une bonne architecture), il n'y a donc plus besoin d'accés global, la seul chose qui reste c'est l'unicté, et pour ca il suffit de ne créer qu'une instance.

Citation:

---

Envoyé par Agoudard

Super, merci les classes de politiques c'est exactement ce que je cherchais, mais je savais pas que ça existé !
Rassurez moi c'est quand même un concept relativement avancé du c++ non ? Je dois m'y reprendre à plusieurs fois avant de saisir les fonctionnements expliqués dans les liens...

Pour ce qui est du singleton du gestionnaire de ressources, je n'ai aucun intérêt à avoir plusieurs instances d'une classe qui vise à centraliser la gestion de la mémoire et plus précisément à limiter les chargements depuis le disque... Donc il me semble qu'un singleton est justifié dans ce cas.

---

J'appellerais pas ça du C++ avancé, mais c'est pas non plus du tout venant...

Citation:

---

Envoyé par Goten

J'appellerais pas ça du C++ avancé, mais c'est pas non plus du tout venant...

---

Adrei Alexandrescu dirait du C++ moderne. D'où le titre de son bouquin.

Oui mais il l'a sorti y'a longtemps :mrgreen:

Citation:

---

Envoyé par Goten

Oui mais il l'a sorti y'a longtemps :mrgreen:

---

Il n'empêche que le coté meta-programmation est par certains aspects très moderne. Il faut du temps pour bien apprécier la force des templates, et les évolutions du standard vont encore améliorer les choses (notamment les évolutions sur SFINAE, qui vont faire beaucoup de bien).

Rebonjour,

Je suis de retour avec un problème dans les classes de politiques. Je pense n'avoir pas totalement cerné le fonctionnement.

Je tente donc d'avoir une méthode du genre :

Code:

---

1 2	CResourceManager::get().load<LoaderPolicy>(QString filename);

---

Avec un type de retour qui me pose problème...
J'aimerais qu'il y est un lien entre LoaderPolicy et le type de retour.
J'ai essayé :

Code:

---

1 2	QSharedPointer<typename LoaderPolicy::ret_type>

---

Mais le compilo m'indique que la méthode load de CResourceManager est introuvable...

Voici le code en détails

CResourceManager :

Code:

---

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

class CResourceManager : QObject { Q_OBJECT   public: static CResourceManager& get();   template<typename TLoader> QSharedPointer<typename TLoader::ret_type> load(QString filename){ return TLoader::load(filename); }   private: CResourceManager(); ~CResourceManager(); };

---

TTextureLoaderPolicy :

Code:

---

1 2 3 4 5 6 7 8 9 10

struct TTextureLoaderPolicy{   static const GLuint ret_type;   static QSharedPointer<GLuint> load(QString filename){ .... return QSharedPointer<GLuint>(// Un pointeur quelconque); } };

---

Quelqu'un peut m'éclairer sur mon erreur ?

CResourceManager::get().template load<LoaderPolicy>(QString filename);

Euh, alors là... je suis complètement paumé.
Pourquoi le mot clé template est nécessaire ?

dans :

Code:

---

1 2	CResourceManager::get().template load<TLoaderPolicy>(QString filename);

---

Il faut préciser que la méthode load est un template ?
Pourquoi ce mot clé n'est pas présent dans tout les cas ?

Merci pour le coup de main ;)

AHA ! J'ai trouvé !

Voilà la solution :

main.cpp

Code:

---

1 2 3 4 5 6 7 8 9

int main(int argc, char* argv[]){   QApplication app(argc, argv);   CResourceManager::get().load<TTextureLoaderPolicy>(QString("test"));   return app.exec(); }

---

ResourceManager.h

Code:

---

1 2 3 4 5 6 7

... template<typename TLoaderPolicy> typename TLoaderPolicy::ret_type load(QString filename){ return TLoaderPolicy::load(filename); } ...

---

TextureLoaderPolicy :

Code:

---

1 2 3 4 5 6 7 8 9

struct TTextureLoaderPolicy{ typedef GLuint ret_type; // Anciennement : static const GLuint ret_type; static GLuint load(QString filename){ return 0; } };

---

Voilà :) Merci pour le coup de main.

S'agit-il d'une solution acceptable ? Pour ajouter un loader il me suffit de créer une classe de politique, et faire l'appel au gestionnaire avec cette classe comme paramètre de template.