是否可以在C++；使用默认泛型参数？ 是否可以在C++中用默认的泛型参数定义λ？ int main(){ auto lambda = [](auto i = 0){return i;}; std::cout<<lambda()<<"\n"; // this does not compile std::cout<<lambda(4)<<"\n"; // this does compile auto lambda2 = [](int i = 0){return i;}; std::cout<<lambda2()<<"\n"; // this is also OK } intmain（）{ 自动lambda=[]（自动i=0）{return i；}； std：：cout

您可以使用包装器实现这一点：

template<class F, class DefaultArg>
struct DefaultArgWrapper
{
    F f;
    DefaultArg default_arg;

    template<class... Args>
    decltype(auto) operator()(Args&&... args) {
        return f(std::forward<Args>(args)...);
    }

    decltype(auto) operator()() {
        return f(default_arg);
    }
};

template<class F, class DefaultArg>
DefaultArgWrapper<F, DefaultArg> with_default_arg(F&& f, DefaultArg arg) {
    return {std::move(f), std::move(arg)};
}

int main(){
    auto lambda = with_default_arg([](auto i){return i;}, 0);
    std::cout<<lambda()<<"\n"; 
    std::cout<<lambda(4)<<"\n";
}

模板
结构DefaultArgWrapper
{
F；
DefaultArg default_arg；
模板
decltype（自动）运算符（）（Args&&…Args）{
返回f（标准：：转发（参数）…）；
}
decltype（自动）运算符（）（）{
返回f（默认参数）；
}
};
模板
带有默认参数的DefaultArgWrapper（F&&F，DefaultArg-arg）{
返回{std:：move（f），std:：move（arg）}；
}
int main（）{
自动lambda=带有默认参数（[]（自动i）{return i；}，0）；
std:：coutostein with
lambda
是指它将生成类似于
struct lambda{template auto operator（）（ti=1）const{return i；}；
的内容，它不能用作
lambda{}（）。在C++中使用模板lambda将成为可能。20@Jarod42但是为什么演绎在你的例子中不起作用呢？相关/重复：@HolyBlackCat:“非演绎的上下文是：[……]-在函数参数的参数类型中使用的模板参数，该参数具有一个默认参数，该默认参数正用于正在进行参数推导的调用。”……有一点需要注意，与“true”不同默认参数，即初始化
arg
的表达式，在创建函子时只计算一次。这也可能有一些意外的生命周期交互，例如
DefaultArg
是
std:：initializer\u list
的实例，如
bool my\u排序（const std:：vector&v）
…
带有默认参数（我的参数已排序，{1,2,3}）//UB on call
@ArneVogel您的反例无法编译，因为它无法从
{1,2,3}推断
DefaultArg
。虽然你说的很对，但它在某些方面可能很重要，但我还没有看到生产代码会在哪里。大多数情况下，默认参数都是普通类型。
template<class F, class DefaultArg>
struct DefaultArgWrapper
{
    F f;
    DefaultArg default_arg;

    template<class... Args>
    decltype(auto) operator()(Args&&... args) {
        return f(std::forward<Args>(args)...);
    }

    decltype(auto) operator()() {
        return f(default_arg);
    }
};

template<class F, class DefaultArg>
DefaultArgWrapper<F, DefaultArg> with_default_arg(F&& f, DefaultArg arg) {
    return {std::move(f), std::move(arg)};
}

int main(){
    auto lambda = with_default_arg([](auto i){return i;}, 0);
    std::cout<<lambda()<<"\n"; 
    std::cout<<lambda(4)<<"\n";
}

template<class... F>
struct ComposeF : F... {
    template<class... F2>
    ComposeF(F2&&... fs)
        : F(std::forward<F2>(fs))...
    {}
    using F::operator()...;
};

template<class... F>
ComposeF<std::decay_t<F>...> composef(F&&... fs) {
    return {std::forward<F>(fs)...};
}

int main() {
    auto lambda = [](auto i) { return i; };
    auto f = composef(lambda, [&lambda](int i = 0) { return lambda(i); });
    std::cout << f() << '\n';
    std::cout << f(1) << '\n';
}