如何编写替代链式方法调用的可变参数方法？

Question

我正在研究一个名为group_by的递归映射类，它对SQL同名进行建模。

例如GB是group_by对象将存储指针foo由std::string，int，和char密钥类型分组，按照该顺序。

group_by<foo,std::string,int,char> gb; 

group_by提供了可用于查找内部电流电平图的at(I const& key)存取方法。链接at()调用检索更深的地图工作正常。

auto& v = gb.at(k1).at(k2).at(k3).get_vec(); 

问题

我想创建一个名为at_variadic(Args const& ...args)的at()替代它可以检索更深的地图都在同一个电话，没有链接。

auto& w = gb.at_variadic(k1, k2); 
auto& x = gb.at_variadic(k1, k2, k3); 

不过，我遇到了一些问题。首先，我不知道如何指定返回类型，因为它取决于可变参数。或许使用decltype()，不知何故？

WORKING ANSWER

Ecatmur's answer below提出了一个很好的方法。

我不得不玩group_by<>的终端案例，以使编译器感到高兴，但下面的代码，大量基于Ecatmur的答案，似乎与gcc 4.7.2工作正常。

#include <cassert> 
#include <map> 
#include <vector> 
#include <iostream> 

template< typename T, typename... Args > 
struct group_by 
{ 
    using child_type = T; 

    std::vector<T*> m_vec; 

    void insert(T* t) 
    { 
     m_vec.push_back(t); 
    } 

    child_type& 
    at(size_t i) 
    { 
     return *m_vec[i]; 
    } 
}; 

template< typename T, typename I, typename... Args > 
struct group_by<T,I,Args...> 
{ 
    using child_type = group_by<T,Args...>; 

    std::map<I,child_type> m_map; 

    void insert(T* t) 
    { 
     m_map[ *t ].insert(t); 
    } 

    child_type& at(I const& key) 
    { 
    return m_map.at(key); 
    } 

    template<typename... Ks> 
    auto 
    at(I const& i, Ks const&...ks) 
    -> decltype(m_map.at(i).at(ks...)) 
    { 
     return m_map.at(i).at(ks...); 
    } 
}; 

// ----------------------------------------------------------------------------- 

struct foo 
{ 
    std::string s; 
    int   i; 
    char   c; 

    operator std::string() const { return s; } 
    operator int  () const { return i; } 
    operator char  () const { return c; } 

    bool operator==(foo const& rhs) const 
    { 
     return s==rhs.s && i==rhs.i && c==rhs.c; 
    } 
}; 

int main(int argc, char* argv[]) 
{ 
    foo f1{ "f1", 1, 'z' }; 
    foo f2{ "f2", 9, 'y' }; 
    foo f3{ "f3", 3, 'x' }; 
    foo f4{ "f1", 4, 'k' }; 

    group_by<foo,std::string,int,char> gb; 

    gb.insert(&f1); 
    gb.insert(&f2); 
    gb.insert(&f3); 
    gb.insert(&f4); 

    std::string k1{ "f1" }; 
    int   k2{ 1 }; 
    char  k3{ 'z' }; 

    auto& a = gb.at(k1).at(k2).at(k3).at(0); 
    auto& b = gb.at(k1).at(k2).m_map; 
    auto& c = gb.at(k1).m_map; 
    auto& d = gb.at(k1, k2).m_map; 
    auto& e = gb.at(k1, k2, k3).m_vec; 
    auto& f = gb.at(k1, k2, k3, 0); 

    assert(a==f1); 
    assert(b.size()==1); 
    assert(c.size()==2); 
    assert(d.size()==1); 
    assert(e.size()==1); 
    assert(f==f1); 

    return 0; 
} 

Answer 1

链式方法调用本质上是递归的，所以你需要实现at递归：

child_type& at(I const& key) { 
    return m_map.at(key); 
} 

template<typename J, typename... Ks> 
auto at(const I &i, const J &j, const Ks &...ks) 
-> decltype(m_map.at(i).at(j, ks...)) { 
    return m_map.at(i).at(j, ks...); 
} 

注意，由于at至少需要1说法，一个可变的形式至少需要2个参数。这比在sizeof...上调度更容易实现，并且应该更易于阅读。