22

次のようなコードがあるとします。

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

これで、パラメーターをスキップしてデフォルト値のままにすることはできないことがわかりました。これは、その値がその位置のパラメーターとして評価されるためです。私が言いたいのは、 call, と言うことができないということですf(a,c)。なぜなら、cが として評価されるbからですc。呼び出し元の関数が C++ で指定する方法はありますか? 最後のパラメーターから none に戻ることに制限されることなく、関数の任意の位置にある既定のパラメーター値を使用する方法はありますか? これを達成するための予約済みキーワード、または少なくとも回避策はありますか? 私が与えることができる例は次のようになります：

f(a, def, c) //Where def would mean default.
4

5 に答える 5

16

これには予約語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

x と y の値を指定せずに、z にユーザー定義の値を指定することはできないことに注意してください。これは、C++ が printValues(,,3) などの関数呼び出し構文をサポートしていないためです。これには、次の 2 つの主要な結果があります。

1) すべてのデフォルト パラメータは、右端のパラメータでなければなりません。以下は許可されていません。

void printValue(int x=10, int y); // not allowed

2) 複数のデフォルト パラメータが存在する場合、最も左端のデフォルト パラメータは、ユーザーによって明示的に設定される可能性が最も高いパラメータである必要があります。

于 2016-08-06T18:16:08.930 に答える
13

回避策として、( c++17boost::optionalまで) 以下を (ab) 使用することができます。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);
于 2016-08-06T23:00:35.943 に答える
10

まさにあなたが求めたものではありませんが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 からのみ使用できることを考慮してください。

于 2016-08-06T18:26:40.870 に答える
1

あなたはすでに受け入れられた答えを持っていますが、ここに別の回避策があります(私は信じています-他の提案された回避策よりも利点があります):

引数を厳密に型指定できます。

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

利点:

  • シンプルで保守が簡単です (引数ごとに 1 行)。
  • API をさらに制限するための自然なポイントを提供します (たとえば、「B の値が負の場合にスローする」)。
  • 邪魔になりません（デフォルトの構築で動作し、インテリセンス/オートコンプリート/他のクラスと同じように動作します）
  • それは自己文書化です。
  • ネイティブ バージョンと同じくらい高速です。

短所:

  • 名前の汚染が増加します（これらすべてを名前空間に配置することをお勧めします）。
  • シンプルですが、(関数を直接定義するだけでなく) 維持するコードが増えます。
  • いくつかの眉をひそめるかもしれません (強い型付けが必要な理由についてコメントを追加することを検討してください)
于 2016-09-28T16:51:28.427 に答える
1

関数のすべてのパラメーターが異なる型である場合、渡されたパラメーターと渡されなかったパラメーターを見つけて、後者のデフォルト値を選択できます。

特殊な型の要件を達成するために、パラメーターをラップして可変引数関数テンプレートに渡すことができます。次に、引数の順序でさえ問題になりません。

#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

于 2016-08-06T19:21:07.123 に答える