使函数接受其参数列表的任何排列的规范方法是什么？

Question

假设我有

class A,B,C;

const A a_def;
const B b_def;
const C c_def;

void f(A a=a_def, B b=b_def, C c=c_def);

这个，如果我想使用默认参数，只允许我省略 c 或 b 和 c，或全部三个 - 但不仅仅是 a 或 b 单独。但是，由于参数类型不能混合，因此调用 f(A(), C()) 是完全明确的，（或者实际上 f(B(), C (), A())：参数的顺序是任意的，实际上没有意义）。

为了启用这些调用函数的替代方法，我现在倾向于手动重载每个排列

void f(A a, C c,       B b=b_def) { f(a,b,c); }
void f(B b, A a=a_def, C c=c_def) { f(a,b,c); }
void f(B b, C c,       A a=a_def) { f(a,b,c); }
void f(C c, A a=a_def, B b=b_def) { f(a,b,c); }
void f(C c, B b,       A a=a_def) { f(a,b,c); }

，这对于仅三个参数（3！= 6 个排列）来说是可以接受的，但在四个参数（4！= 24 个排列）时变得乏味，在五个参数时超出范围参数（5！= 120 排列）。

有没有什么方法可以自动获得此功能，而无需实际执行所有重载，例如通过变量参数列表或某种模板元编程？

Answer 1

创建一个结构体来传递参数。

class Params{
 public:
   Params();// set defaults
   Params& A(int);
   Params& B(int);
   int a,b;
};

然后打电话

 f(Params().A(5));

Answer 2

恕我直言，通常最好的解决方案是定义一个结构来传递参数。

但你声明你不想要那样，你想要正常的使用符号。

在这种情况下，Boost 参数库是最简单的。

如果你不能使用Boost，你可以自己做。

然而，DIY 类似“Boost 参数”的解决方案的代码量是参数数量的二次方，尽管二次方比阶乘好得多，但它仍然有点令人望而却步……我在下面给出了一个代码示例。主要思想是按类型识别参数，然后在编译时轻松对它们进行排序。

template< class Type >
struct Pointer
{
    Type const* p_;
    Pointer( Type* p = 0 ): p_( p ) {}
};

template< class Type, class Args >
Type const* pointer( Args const& args )
{
    return static_cast< Pointer< Type > const& >( args ).p_;
}

template< class Type, class Args >
Type const*& pointerRef( Args& args )
{
    return static_cast< Pointer< Type >& >( args ).p_;
}


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

class A {};  class B {};  class C {};
A const a_def;  B const b_def;  C const c_def;

void foo( A const* pa, B const* pb, C const* pc )
{
    A const&    a = (pa? *pa : a_def);
    B const&    b = (pb? *pb : b_def);
    C const&    c = (pc? *pc : c_def);

    // Whatever, use a b c here.
}

struct FooArgs
    : Pointer< A >
    , Pointer< B >
    , Pointer< C >
{};

void foo( FooArgs const& args )
{
    foo( pointer< A >( args ), pointer< B >( args ), pointer< C >( args ) );
}

void foo()
{
    foo( FooArgs() );
}

template< class T1 >
void foo( T1 const& v1 )
{
    FooArgs     args;

    pointerRef< T1 >( args ) = &v1;
    foo( args );
}

template< class T1, class T2 >
void foo( T1 const& v1, T2 const& v2 )
{
    FooArgs     args;
    pointerRef< T1 >( args ) = &v1;
    pointerRef< T2 >( args ) = &v2;
    foo( args );
}

template< class T1, class T2, class T3 >
void foo( T1 const& v1, T2 const& v2, T3 const& v3 )
{
    FooArgs     args;
    pointerRef< T1 >( args ) = &v1;
    pointerRef< T2 >( args ) = &v2;
    pointerRef< T3 >( args ) = &v3;
    foo( args );
}

int main()
{
    foo( B() );
}

如前所述，DIY 的东西将是我最后的选择。

我在此示例代码中省略了错误检查。例如，如果两个或多个实际参数具有相同类型，则不应编译代码。我还省略了对形式参数并非都是同一类型的情况的概括。这些被省略的事情导致了更多的复杂性。因此，如果上述内容看起来令人望而却步，请考虑“完整版本”中的情况，可以这么说。

对于需要严格类型化的可选参数（例如类层次结构中的构造函数）的情况，请参阅我的博客文章 "如何在 C++98 中执行类型化可选参数"。

干杯&呵呵，

Answer 3

查看 Boost.Parameters 库。它使用一些模板繁重的工作来使其工作。 http://www.boost.org/doc /libs/1_37_0/libs/parameter/doc/html/index.html

它的工作原理基本上是将“命名”参数转换为可以创建和分配的类型。

Answer 4

混合 C++0x 和一点 Boost（后者您可以轻松替换）：

typedef boost::variant<A,  B, C> Arg;
void f(std::initializer_list<Arg> args)
{
    A *a = NULL;
    B *b = NULL;
    C *c = NULL;

    // for each arg, assign to a, b, or c,
    // possibly throwing if one type is used multiple times

    if (!a)
        a = new A();
    // and similar for B and C, or use smarter pointer types

    f(*a, *b, *c);
}

像这样调用，这只是比应有的样子稍微难看一点：

f({C(), B()});

我还没有测试过这个，但我认为它可以工作。