Question

我有这样的代码和平：

#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;
}

我只是想知道如何使静态方法loader::load起作用。我希望此方法有两个重载，一个使用模板参数storage，第二个使用模板参数state_type（现在就是这样，但它不起作用）。< / p>

有任何想法吗？

谢谢。

Answer 1

第二个参数inner_type的{{1}}是non-deduced context。

如果您的参数类型为storage_template<inner_type>::state_type，则编译器无法在不尝试所有可能类型的情况下从T推断出inner_type，并查看是否有任何结果在T storage_template<any_type>::state_type。

标准认为这样做太多了，所以编译器不应该尝试。

模板类的嵌套结构作为泛型方法的参数

1 个答案: