如何编写接收带默认参数lambda的泛型函数及实现带默认函数的泛型设置器

1. 编写接收带默认参数lambda的泛型函数 #

带默认参数的lambda本质是它的operator()成员函数带有默认参数，但这里有个容易踩的坑：直接传递lambda给泛型函数时，编译器能正确识别默认参数；但如果把lambda转换成std::function这类固定签名的类型，默认参数会直接丢失，因为std::function的签名是严格固定的。

情况1：直接传递lambda给泛型函数 #

你可以直接写一个模板函数，接收任意可调用对象，调用时根据需求选择传参或不传参（不传参时lambda会自动使用默认值）：

#include <iostream>

template <typename Func>
void invoke_lambda(Func&& func) {
    // 不传参数，触发lambda的默认参数
    func();
    // 传递参数覆盖默认值
    func(42);
}

int main() {
    auto my_lambda = [](int x = 10) {
        std::cout << "x的值是: " << x << std::endl;
    };

    invoke_lambda(my_lambda);
    return 0;
}

这段代码里，invoke_lambda是泛型函数，能兼容所有可调用对象，包括带默认参数的lambda，调用逻辑完全由lambda自身的默认参数规则处理。

情况2：保留默认参数同时存储为std::function #

如果需要把lambda存入std::function且保留默认参数能力，直接转换行不通，因为std::function的签名是固定的（比如std::function<void()>和std::function<void(int)>是完全不同的类型）。这时可以封装一个简单的包装类来处理：

#include <iostream>
#include <functional>

template <typename Func>
class LambdaWrapper {
private:
    Func func_;
public:
    LambdaWrapper(Func func) : func_(std::move(func)) {}

    // 无参调用，触发lambda默认参数
    void operator()() const {
        func_();
    }

    // 带参调用，转发参数
    template <typename... Args>
    void operator()(Args&&... args) const {
        func_(std::forward<Args>(args)...);
    }
};

// 辅助函数，简化包装类的创建
template <typename Func>
auto wrap_lambda(Func&& func) {
    return LambdaWrapper<std::decay_t<Func>>(std::forward<Func>(func));
}

template <typename WrappedFunc>
void call_wrapped(WrappedFunc&& func) {
    func();
    func(100);
}

int main() {
    auto my_lambda = [](int x = 10) {
        std::cout << "x的值是: " << x << std::endl;
    };

    auto wrapped = wrap_lambda(my_lambda);
    call_wrapped(wrapped);
    return 0;
}

这个包装类同时支持无参和带参调用，完美保留了lambda的默认参数特性。

2. 实现带默认函数的泛型设置器与函数存储 #

这个需求的核心是：维护一个存储函数的变量，通过泛型设置器赋值，未赋值时自动使用默认函数。用类封装逻辑会更清晰、易维护：

基础实现（固定函数签名） #

#include <iostream>
#include <functional>

// 默认函数：这里定义一个简单的默认逻辑
void default_process(int x) {
    std::cout << "调用默认函数，输入值: " << x << std::endl;
}

class FuncHolder {
private:
    // 存储函数的变量，初始化时绑定默认函数
    std::function<void(int)> func_ = default_process;
public:
    // 泛型设置器：接受任意可调用对象（lambda、普通函数、函数对象等）
    template <typename Func>
    void set_function(Func&& new_func) {
        func_ = std::forward<Func>(new_func);
    }

    // 调用存储的函数
    void execute(int x) {
        func_(x);
    }
};

int main() {
    FuncHolder holder;

    // 初始状态：调用默认函数
    holder.execute(5);

    // 设置自定义lambda
    holder.set_function([](int x) {
        std::cout << "调用自定义lambda，输入值: " << x << std::endl;
    });

    holder.execute(42);
    return 0;
}

关键点说明 #

• 用std::function作为存储类型，能兼容各种可调用对象，保证类型安全。
• 默认函数在初始化时赋值给func_，确保即使未调用设置器也有可用的函数逻辑。
• 泛型设置器用std::forward实现完美转发，避免不必要的对象拷贝。

进阶：支持任意函数签名的模板版 #

如果需要适配不同的函数签名，可以把FuncHolder做成模板类：

#include <iostream>
#include <functional>

template <typename Signature>
class GenericFuncHolder {
private:
    std::function<Signature> func_;
    std::function<Signature> default_func_;
public:
    // 构造时传入默认函数
    GenericFuncHolder(std::function<Signature> default_func) 
        : default_func_(std::move(default_func)), func_(default_func_) {}

    template <typename Func>
    void set_function(Func&& new_func) {
        func_ = std::forward<Func>(new_func);
    }

    // 转发调用参数，支持任意参数列表
    template <typename... Args>
    auto execute(Args&&... args) {
        return func_(std::forward<Args>(args)...);
    }

    // 重置为默认函数
    void reset_to_default() {
        func_ = default_func_;
    }
};

// 示例使用
int main() {
    // 默认函数：无参返回int
    auto default_no_arg = []() -> int { return 0; };
    GenericFuncHolder<int()> holder(default_no_arg);

    std::cout << holder.execute() << std::endl; // 输出0

    // 设置自定义lambda
    holder.set_function([]() -> int { return 100; });
    std::cout << holder.execute() << std::endl; // 输出100

    holder.reset_to_default();
    std::cout << holder.execute() << std::endl; // 回到0

    return 0;
}

这个模板版本可以适配任意函数签名，灵活性更高，适合需要处理多种函数类型的场景。

内容的提问来源于stack exchange，提问作者user678253