标签: default-arguments

以下 C++ 代码无法编译：

template <typename T>
void f(int, bool = true);

void g()
{
    auto h = f<int>;
    h(1); // error: too few arguments to function
}

相反，我必须h使用第二个参数调用：

h(1, true);

为什么不起作用h(1)？

有没有一种简单的方法来给模板函数添加别名来绑定模板参数，同时保留默认的函数参数？

我是 Erlang 新手，试图找出函数调用的默认值的最佳方法，这需要多个变量和/或也不想按特定顺序输入参数。我目前正在使用这种基于 Clojure 方式的松散格式。在Erlang中是否有更好的方式或方法来实现这一点？我还提供了一个 Clojure 示例作为参考：

二郎版本：

some_function_with_defaults() ->
    some_function_with_defaults(#{}).

some_function_with_defaults(Map) ->
    Defaults = #{
                arg1 => 0, % arg1 default value
                arg2 => 1, % arg2 default value
                arg3 => 2  % arg3 default value
              },

  Arguments = maps:merge(Defaults,Map),

  #{arg1 := Arg1} = Arguments,
  #{arg2 := Arg2} = Arguments,
  #{arg3 := Arg3} = Arguments,

  %% Do something with arguments
  [Arg1,Arg2,Arg3].

%% Example call using only defaults
%% some_function_with_defaults().
%%
%% [0,1,2]

%% Example call specifying a specific value …

在elixir中可以在函数定义中使用默认参数,但我发现使用单个关键字列表参数不可能这样做:

def do_stuff(
  success: sucess \\ fn(conn) -> conn end,
  error: error
) do
  # ...
end

此外,我想通过使用像JS承诺这样的东西避免这种"回调传递"编码风格,但我找不到Elixir的承诺实现.

也许在语言中内置了一些东西,可以帮助我编写更好的代码,更接近elixir标准.

主要问题:是否可以使用默认关键字参数？

附带问题: Elixir是否提供了一些帮助避免这种"回调传递"的编程风格,而采用更具反应性/可组合性的机制？

我在这里看到了一些答案，但它们可能不适用于这里。我有一个（成员）函数，它主要只与一个参数（第一个）一起使用：

const std::complex<double> Class::func(const std::complex<double> &x, \
                                       std::vector<double> &y = 0, \
                                       std::vector<double> &z = 0) const;

我希望 fory并且z是可选的，甚至可能基于 type 的第四个参数string，类似于这样的：func( , , , const std::string &choice)，但这只会让我只将一个参数传递给函数，而其他两个参数不会被使用。y例如，如果我确实通过了，它的声明必须在调用之前完成func()，对于 来说也是如此z，但我希望这是可选的，该函数在数学方面可能有点繁重，无需添加如果不需要，计算两个额外向量的负担。这可能吗？

当我们像这样用 Kotlin 创造乐趣时

fun foo(bar: Int = 0, baz: Int) { /* ... */ }

foo(baz = 1) // The default value bar = 0 is used

所以在java中我们需要这样写

不需要写

void foo(int bar, int baz){
...
}

void foo(int baz){
foo(0,baz);
}

让我们想象一下，如果我们有 10 个以上的参数。我想知道 Kotlin 如何处理这个问题。Kotlin 会生成所有可能的方法吗？或者它只是生成程序员真正使用的方法？

如果我想制作一个可以接受 2 个untyped参数的模板，并通过do符号传递它们，当我省略第二个参数时，do我希望有一种方法以参数的默认值的形式指定回退。像这样：

template tpl(x: bool, body: untyped, bodyFinally: untyped): void =
  if x: body
  else: bodyFinally

#call site:
var r: int
tpl(true) do:
  r = 2
do:
  raise newException(Exception, "")

这有效，但是：

template tpl(x: bool, body: untyped, bodyFinally: untyped = discard): void =
  # same rest

错误：应有表达式，但发现“关键字丢弃”

不接受默认值，消息很奇怪，discard是不是表达式。

尝试解决方法：

template tpl(x: bool, body: untyped, bodyFinally: untyped = proc()): void =
  # same rest

然后我们得到：

错误：表达式 'proc ()' 的类型为 'type proc (){.closure.}' 并且必须被丢弃 …

lambda函数是否更改为接受c ++ 14中的默认参数？

此示例不适用于C ++ 11：

int main() {

    int i = 34;
    auto RectSurf = [i](int length = 0, int width = 0){ return length * width;};
    cout << RectSurf(10) << endl;


    std::cout << std::endl;
}

但是它在C ++ 14及更高版本上可以正常工作。如此正确与否？因为C ++ Prime 5ed表示：“将参数传递给Lambda与普通函数调用一样，对Lambda的调用中的参数用于初始化Lambda的参数。通常，参数和参数类型必须匹配。与普通函数不同，lambda可能没有默认参数（第6.5.1节，第236页），因此，对lambda的调用始终具有与lambda具有参数一样多的参数，一旦参数初始化，函数主体就会执行。

作为带有参数的lambda的示例，我们可以编写一个行为类似于isShorter函数的lambda：“来自C ++ Prime 5ed。

但是在C ++ 14及更高版本上使用相同的代码就可以了！但我也在SO中读到过，如果Lambda的捕获列表中没有捕获任何变量，则lambda函数可以具有默认参数。

我使用以下代码得到“非静态成员引用必须相对于特定对象”，

class A{
    int data;
    int _default = 0;
public:
    A(int data, int _default) : data(data), _default(_default) {}
    void set(int data = _default){ this->data = data; }
};

int main(){
    A a1(1, 1); a1.set(10); a1.set();
    A a2(2, 2); a2.set(20);
}

我想做的事？

• 当我们调用时A.set()，A::data设置为A::_default
• 当我们调用时A.set(a)，A::data设置为a

在Stanley B. Lippman*的书C++入门书中,*JoséeLajoie

在类构造函数的第14.2章中,它指出:

我们是否还应该为指定期初余额但没有客户名称提供支持？碰巧,类规范明确禁止这样做.我们的带有默认第二个参数的双参数构造函数提供了一个完整的接口,用于接受可由用户设置的类Account的数据成员的初始值:

class Account {
public:
       // default constructor ...
       Account();

       // parameter names are not necessary in declaration
       Account( const char*, double=0.0 ); 

       const char* name() { return _name; } // What is this for??
       // ...
private:
       // ...
};

以下是合法的Account类对象定义,将一个或两个参数传递给构造函数:

int main()
{
        // ok: both invoke two-parameter constructor
        Account acct( "Ethan Stern" ); 

当没有使用单个参数声明时,如何调用2参数构造函数？

        Account *pact = new Account( "Michael Lieberman", 5000 );

以上行如何使用默认参数调用构造函数

        if ( strcmp( acct.name(), pact->name() )) …

是否可以使用成员初始化列表的默认参数？

Vector3::Vector3(double xI, double yI, double zI)
: x(xI=0), y(yI=0), z(zI=0)
{
}

即使您通过设置参数调用它,构造函数也始终将x,y和z设置为0.