如何编写替代链式方法调用的可变参数方法？
我正在研究一个名为group_by的递归映射类，它对SQL同名进行建模。
例如，gb是一个group_by对象，它将以std::string ， int和char键类型的顺序存储指向foo指针。
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() ，不知何故？
工作答案
Ecatmur的答案概述了一个好方法。
我不得不使用group_by<>终端case来让编译器感到满意，但下面的代码，基于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;
}
链式方法调用本质上是递归的，所以你需要实现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...上派发更容易实现，并且应该更易于阅读。
上一篇: How to write a variadic method which replaces chained method calls?