Jak napisać metodę variadic, która zastępuje powiązane wywołania metod?

Question

Pracuję nad rekurencyjną klasą map o nazwie group_by, która modeluje nazwę SQL.

Na przykład gb jest group_by obiekt, który będzie przechowywać odnośniki do foo pogrupowane według std::string, int i char głównych typów, w tej kolejności.

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

group_by zapewnia metodę at(I const& key) dostępowej, które mogą być używane do zajrzeć obecnego poziomu mapy. Połączenia łańcuchowe at() w celu pobrania głębszych map działają dobrze.

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

PROBLEM

Chciałbym stworzyć alternatywę at() nazwie at_variadic(Args const& ...args) które można pobrać głębiej mapach wszystkie w jednej rozmowy, bez łączenia.

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

Jednak mam pewne problemy. Przede wszystkim nie wiem, jak określić typ zwracania, ponieważ zależy on od argumentów variadic. Może w jakiś sposób użyć decltype()?

ODPOWIEDŹ PRACA

Ecatmur's answer below przedstawił dobre podejście.

Musiałem się bawić przy obudowie terminalu group_by<>, aby kompilator był zadowolony, ale poniższy kod, oparty w dużej mierze na odpowiedzi Ecatmur, działa dobrze z 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

Chained wywołania metod są zasadniczo rekurencyjne, więc trzeba wdrożyć at rekurencyjnie:

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...); 
} 

Należy pamiętać, że od at wymaga co najmniej 1 argument, postać o zmiennej liczbie argumentów trwa co najmniej 2 parametry. Jest to znacznie łatwiejsze do wdrożenia niż wysyłanie pod numer sizeof... i powinno być łatwiejsze do odczytania.