Discussion :

[DakM]

Bonjour,

Je pense que le sujet n'est pas top, mais je vois pas comment l'exprimer ...
J'ai une classe templatée qui herite d'une autre, pour avoir un type commun, pour pouvoir stocker la premier dans une map .

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
 
template<typename Cast, typename IdType>
struct shared_pointer
{
	typedef std::shared_ptr<Cast> ptr;
	typedef IdType id_t;
};
 
    class item_impl: public shared_pointer<item_impl, fs::size_t> {};
    typedef std::unordered_multimap<item_impl::id_t, item_impl::ptr> loaded_items_t;
    template<typename loadType>
    class loaded_item: public item_impl
    {
    public:
        typedef loadType type;
        loaded_item(fs::node::ptr node, const std::vector<char>& bin);
        virtual ~loaded_item() {}
        loadType& operator()() { return m_data; }
        fs::node::ptr& node() { return m_node; }
    protected:
        fs::node::ptr m_node;
        loadType m_data;
    };

Ensuite, j'ai une autre classe, qui va se charger de la creation :

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
    class node_loader: public basic_exceptions, public shared_pointer<node_loader, std::string>
    {
    public:
        node_loader(fs::pack<std::ifstream>::ptr pl) : m_reader(pl) {}
        virtual ~node_loader() { m_loaded.clear(); }
        template<typename loadType>
        typename loaded_item<loadType>::ptr operator()(item_impl::id_t id)
        {
            auto found(std::find_if(std::begin(m_loaded),
                                    std::end(m_loaded),
                                    [&id](const loaded_items_t::value_type& l)
                                    {
                                        return (l.first == id && std::is_same<loadType, l.second::type>::value);
                                    }));
            if(found == std::end(m_loaded)) throw not_found();
            else return found.second;
        }
    private:
        fs::pack<std::ifstream>::ptr m_reader;
        loaded_items_t m_loaded;
    };

La ligne en rouge, en gros, je voudrais comparer le type donné en argument template avec le type du typedef de l'element iteré (cf: typedef loadType type

Evidemment, le compilo me sors:

error: expected a type, got ‘l.second’|

Une autre facon à laquelle j'avais penser, est de sortir ces templates, et d'avoir un truc qui permettrais de recuperer le type (facon decltype) a partir d'une map... Voici le code que vous pouvez bidouiller !

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#include <map>
#include <iostream>
#include <utility>
#include <typeinfo>
#include <string>
class A {};
class B {};
struct type_forward
            {
                /// NOTE: Add more type-forwarding here
                struct type_impl
                {
                    typedef int key_type;
                };
                struct A_forward: public type_impl
                {
                    typedef A type;
                };
                struct B_forward: public type_impl
                {
                    typedef B type;
                };
                struct string_forward: public type_impl
                {
                    typedef std::string type;
                };
                static std::map<type_impl::key_type, type_impl> type_forwardings;
            };
std::map<type_forward::type_impl::key_type, type_forward::type_impl> type_forward::type_forwardings =
    std::map<type_forward::type_impl::key_type, type_forward::type_impl>();
int main()
{
    type_forward::type_forwardings.insert({1, type_forward::A_forward()});
    type_forward::type_forwardings.insert({2, type_forward::B_forward()});
    type_forward::type_forwardings.insert({3, type_forward::string_forward()});
    auto X(type_forward::type_forwardings.at(1));
    auto XX(type_forward::type_forwardings.at(2));
    auto XXX(type_forward::type_forwardings.at(3));
 
    decltype(X)::type Z; /// Z doit être de type A !
    decltype(XX)::type ZZ; /// ZZ doit être de type B !
    decltype(XXX)::type ZZZ; /// ZZZ doit être de type std::string !
}

germinolegrand me parlais de double dispatch, mais je n'y comprend rien.
ideone > http://ideone.com/VCwgt8

merci d'avance

[Kalith]

Si tu caches le type réel via l'héritage, tu fais ce qu'on appelle du "type erasure", et par définition tu ne peux rien faire à la compilation. Tu peux t'en sortir au runtime en activant la RTTI et en utilisant typeid (en.cppreference.com).

Je te conseille de jeter un oeil à boost::any, ou encore à cet article de Développez qui m'a fait découvrir la notion de "type erasure" il y a quelques années On y explique (entre autre) comment coder son propre boost::any : ce n'est pas compliqué, et c'est très instructif.