Bonjour,

J'aimerais realiser un chargement/dechargement dynamique de ma memoire autour d'une classe X, cette classe étant gerée par la classe Y, qui transformera l'objet X, en une std::map<A, X*>, ou std::map<A, shared_ptr<X>>.

Le but, étant d'utiliser le compteur interne au shared_ptr, et dès qu'il touche 0, l'objet de type X sera decharge de la memoire !

En gros, la classe Y ressemblerait à ceci:
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
18
19
20
21
22
23
24
25
26
27
28
29
30
template<class C, typename T>
class shared_structure
{
public:
    class does_not_exist
    {
    public:
        does_not_exist() {}
        virtual ~does_not_exist() throw() {}
    };
    class not_loaded
    {
    public:
        not_loaded() {}
        virtual ~not_loaded() throw() {}
    };
    shared_structure() { }
    virtual ~shared_structure() {}
    std::shared_ptr<C> get() { return std::make_shared(this); }
    typedef typename std::map<T, std::shared_ptr<C>>& gets_t;
    typedef typename std::pair<const T, std::shared_ptr<C>>& gets_single_t;
    typedef typename std::map<T, std::shared_ptr<C>>::iterator gets_iterator_t;
    static inline gets_t gets() { return structures; }
    static void clear() { structures.clear(); }
    static typename std::map<T, std::shared_ptr<C>>::iterator begin() { return std::begin(structures); }
    static typename std::map<T, std::shared_ptr<C>>::iterator end() { return std::end(structures); }
    std::size_t get_count() const { return use_count(); }
protected:
    static std::map<T, std::shared_ptr<C>> structures;
};
Avec ceci, je peux donc faire...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
class X;
class X: public shared_structure<type_clé, X> {};
Est-ce une bonne façon de faire ?
Comment detecter le compteur touchant 0 et liberer le pointeur ?

Merci, nico