Discussion :

[Agoudard]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
if(loader.isValid<T>()){
        return loader.load<T>(filename);
}

Merci

[Goten]

isValid() fait quoi?

[Agoudard]

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

[Joel F]

ca serait encore mieux sans Singleton

[3DArchi]

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

Sur le singleton : Etes-vous atteint de Singletonite ?

[Emmanuel Deloget]

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.

[Goten]

ca serait encore mieux sans Singleton

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

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

[Flob90]

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.

[Goten]

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

[Emmanuel Deloget]

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.

[Goten]

Oui mais il l'a sorti y'a longtemps

[Emmanuel Deloget]

Oui mais il l'a sorti y'a longtemps

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

[Agoudard]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Goten]

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

[Agoudard]

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

dans :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Agoudard]

AHA ! J'ai trouvé !

Voilà la solution :

main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
...
    template<typename TLoaderPolicy>
    typename TLoaderPolicy::ret_type load(QString filename){
        return TLoaderPolicy::load(filename);
    }
...

TextureLoaderPolicy :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.