Question

假设我有这样的代码：

void f(int a = 0, int b = 0, int c = 0)
{
    //...Some Code...
}

正如您可以通过我的代码明显看到的那样，参数a，b和c的默认参数值为0.现在看看我的主要功能如下：

int main()
{
   //Here are 4 ways of calling the above function:
   int a = 2;
   int b = 3;
   int c = -1;

   f(a, b, c);
   f(a, b);
   f(a); 
   f();
   //note the above parameters could be changed for the other variables
   //as well.
}

现在我知道我不能只跳过一个参数，并让它具有默认值，因为该值将作为该位置的参数进行评估。我的意思是，我不能，比如打电话f(a,c)，因为，c会被评估为b，这是我不想要的，特别是{{1}是错误的类型。有没有一种方法让调用函数在C ++中指定，在任何给定的位置使用函数的任何默认参数值，而不限于从最后一个参数向后转到无？是否有任何保留关键字来实现这一目标，或者至少是解决方法？我可以给出一个例子：

Answer 1

此处没有保留字，f(a,,c)也无效。你可以省略一些最右边的可选参数，如你所示，但不能省略那样的中间可选参数。

http://www.learncpp.com/cpp-tutorial/77-default-parameters/

直接从上面的链接引用：

多个默认参数

一个函数可以有多个默认参数：
void printValues(int x=10, int y=20, int z=30)
{
    std::cout << "Values: " << x << " " << y << " " << z << '\n';
}
给出以下函数调用：
printValues(1, 2, 3);
printValues(1, 2);
printValues(1);
printValues();
生成以下输出：
Values: 1 2 3
Values: 1 2 30
Values: 1 20 30
Values: 10 20 30
请注意，无法为z提供用户定义的值   不提供x和y的值。这是因为C ++确实如此   不支持函数调用语法，如printValues（,, 3）。这有   两个主要后果：

1）所有默认参数必须是最右边的参数。该   以下是不允许的：
void printValue(int x=10, int y); // not allowed
2）如果存在多个默认参数，则最左边的默认参数参数应该是最有可能被显式设置的参数用户。

Answer 2

作为解决方法，您可以（ab）使用boost::optional（直到来自c ++ 17的std::optional）：

void f(boost::optional<int> oa = boost::none,
       boost::optional<int> ob = boost::none,
       boost::optional<int> oc = boost::none)
{
    int a = oa.value_or(0); // Real default value go here
    int b = ob.value_or(0); // Real default value go here
    int c = oc.value_or(0); // Real default value go here

    //...Some Code...
}

然后调用它

f(a, boost::none, c);

Answer 3

不完全符合您的要求，但您可以使用std::bind()来修复参数值。

有些想法

#include <functional>

void f(int a = 0, int b = 0, int c = 0)
{
    //...Some Code...
}

int main()
{
   //Here are 4 ways of calling the above function:
   int a = 2;
   int b = 3;
   int c = -1;

   f(a, b, c);
   f(a, b);
   f(a); 
   f();
   //note the above parameters could be changed for the other variables
   //as well.

   using namespace std::placeholders;  // for _1, _2

   auto f1 = std::bind(f, _1, 0, _2);

   f1(a, c); // call f(a, 0, c);

   return 0;
}

使用std::bind()，您可以修复与默认参数值不同的值或没有默认值的参数值。

只计算std::bind()仅在C ++ 11中可用。

p.s：抱歉我的英语不好。

Answer 4

如果函数的所有参数都是不同类型，您可以找出传递的参数和未传递的参数，并选择后者的默认值。

为了实现不同的类型要求，您可以包装参数并将其传递给可变参数函数模板。那么即使论证的顺序也不重要了：

#include <tuple>
#include <iostream>
#include <type_traits>

// -----
// from http://stackoverflow.com/a/25958302/678093
template <typename T, typename Tuple>
struct has_type;

template <typename T>
struct has_type<T, std::tuple<>> : std::false_type {};

template <typename T, typename U, typename... Ts>
struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};

template <typename T, typename... Ts>
struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};

template <typename T, typename Tuple>
using tuple_contains_type = typename has_type<T, Tuple>::type;
//------


template <typename Tag, typename T, T def>
struct Value{
    Value() : v(def){}
    Value(T v) : v(v){}
    T v; 
};

using A = Value<struct A_, int, 1>;
using B = Value<struct B_, int, 2>;
using C = Value<struct C_, int, 3>;


template <typename T, typename Tuple>
std::enable_if_t<tuple_contains_type<T, Tuple>::value, T> getValueOrDefaultImpl(Tuple t)
{
    return std::get<T>(t);
}

template <typename T, typename Tuple>
std::enable_if_t<!tuple_contains_type<T, Tuple>::value, T> getValueOrDefaultImpl(Tuple)
{
    return T{};
}

template <typename InputTuple, typename... Params>
auto getValueOrDefault(std::tuple<Params...>, InputTuple t)
{
    return std::make_tuple(getValueOrDefaultImpl<Params>(t)...);
}

template <typename... Params, typename ArgTuple>
auto getParams(ArgTuple argTuple) 
{
    using ParamTuple = std::tuple<Params...>;
    ParamTuple allValues = getValueOrDefault(ParamTuple{}, argTuple);
    return allValues;
}

template <typename... Args>
void f(Args ... args)
{
    auto allParams = getParams<A,B,C>(std::make_tuple(args...));
    std::cout << "a = " << std::get<A>(allParams).v << " b = " << std::get<B>(allParams).v << " c = " << std::get<C>(allParams).v << std::endl;
}

int main()
{
   A a{10};
   B b{100};
   C c{1000};

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

<强>输出

a = 10 b = 100 c = 1000
a = 10 b = 100 c = 1000
a = 10 b = 100 c = 3
a = 10 b = 2 c = 3
a = 1 b = 2 c = 3

live example

Answer 5

编辑：这个问题比较旧了，当另一个问题被重复关闭（抄袭）时，我发现了这个问题。

您已经有了一个已接受的答案，但这是另一种解决方法（我相信 - 它比其他提议的解决方案更具优势）：

您可以强类型化参数：

struct A { int value = 0; };
struct B { int value = 2; };
struct C { int value = 4; };

void f(A a = {}, B b = {}, C c = {}) {}
void f(A a, C c) {}

int main()
{
    auto a = 0;
    auto b = -5;
    auto c = 1;

    f(a, b, c);
    f(a, C{2});
    f({}, {}, 3);
}

优点：

它简单易维护（每个参数一行）。
提供了进一步限制API的自然点（例如，“如果B的值为负则抛出”）。
它不会妨碍（使用默认构造，使用intellisense / auto-complete /任何其他类别）
它是自我记录的。
它和原生版本一样快。

缺点：

增加名称污染（最好将所有这些放在命名空间中）。
虽然简单，但仍需要维护更多代码（而不仅仅是直接定义函数）。
它可能会引起一些人的注意（考虑添加评论为什么需要强类型）

调用C ++函数时指定默认参数

5 个答案: