Verschachtelte Struktur der Template-Klasse als Parameter der generischen Methode

Question

ich einen solchen Frieden von Code haben:

#include <map> 

class empty_class 
{ 

}; 

template <typename base_class = empty_class> 
class traits : public base_class 
{ 
public: 
    typedef int id; 
    typedef std::map<id, id> ids; 
}; 

class simple_traits 
{ 
public: 
    typedef double id; 
    typedef std::map<id, id> ids; 
}; 

template <typename base_class = traits<>> 
class storage_template : public base_class 
{ 
public: 
    typedef typename base_class::id id; 
    typedef typename base_class::ids ids; 

    struct state; 
    typedef state state_type; 

public: 
    struct state 
    { 
     ids m_ids; 
    }; 

public: 
    inline state_type & get_state() 
    { 
     return m_state; 
    } 

    inline void set_state(state_type & state) 
    { 
     m_state = state; 
    } 

protected: 
    state_type m_state; 
}; 

typedef storage_template<>     default_storage; 
typedef storage_template<simple_traits>  simple_storage; 

class loader 
{ 
public: 
    template <class inner_type> 
    static bool load(const char * filepath, typename storage_template<inner_type>::state_type & state) 
    { 
     /* further actions */ 
     return true; 
    } 

    template <class inner_type> 
    static bool load(const char * filepath, typename storage_template<inner_type> & storage) 
    { 
     return load(filepath, storage.get_state()); 
    } 
}; 

int main(void) 
{ 
    default_storage storage_1; 
    simple_storage storage_2; 

    loader::load("filepath", storage_1.get_state()); 
    loader::load("filepath", storage_2.get_state()); 

    loader::load("filepath", storage_1); 
    loader::load("filepath", storage_2); 

    return 0; 
} 

Ich frage mich nur, wie statische Methode machen loader::load Arbeit. Ich hätte gerne zwei Überladungen dieser Methode, eine mit Template-Parameter storage, zweite mit Template-Parameter state_type (wie es jetzt ist, aber es funktioniert nicht).

Haben Sie irgendwelche Ideen?

Vielen Dank.

Answer 1

Der inner_type des zweiten Parameters storage_template<inner_type>::state_type ist ein non-deduced context.

Wenn Sie einen Parametertyp T haben, kann der Compiler ableiten nicht inner_type von T ohne alle mögliche Typen ausprobieren und sehen, ob diese Ergebnisse in storage_template<any_type>::state_typeT zu sein.

Der Standard besagt, dass dies viel zu viel funktioniert, also sollten die Compiler das nicht versuchen.