带捕获的lambda配合std::semiregular使用时编译失败的解决方案

编译失败的核心原因是std::semiregular概念要求类型同时满足可默认构造、可拷贝、可移动：

• 无捕获的lambda自带默认构造、拷贝、移动语义，完全满足std::semiregular约束，因此可以正常编译
• 带任意捕获的lambda没有默认构造函数，不满足std::semiregular的约束要求，类模板参数推导（CTAD）阶段直接触发约束检查失败，就是你看到的报错信息。
  另外当前实现中构造函数写了默认参数F get = F{}，这本身也强制要求F必须支持默认构造，和semiregular的约束叠加后直接拦截了带捕获lambda的传入。

方案1：放宽F的类型约束（推荐，零开销） #

实际业务逻辑中RestApiImpl只需要在构造时移动传入的回调函数，根本不需要回调类型支持默认构造，因此可以直接把过严的std::semiregular约束替换为符合实际使用需求的std::move_constructible，同时去掉构造函数的默认参数即可：

#include <concepts>
#include <functional>
#include <iostream>

template<typename T>
concept OperatorLike = requires(T t, std::string s) {
    { t[s] } -> std::same_as<std::string>;
};

template<typename T, typename O>
concept Gettable = requires(T t, O op) { 
t.apply_post(0, op); };

// 替换约束为std::move_constructible
template<std::move_constructible F>
class RestApiImpl {
    F m_post_method;
public:
    // 去掉=F{}默认参数，不需要默认构造回调
    RestApiImpl(F get) : m_post_method{std::move(get)} {}

    template<OperatorLike IF>
    requires std::invocable<F, const int, IF>
    void apply_post(const int req, IF interface){ 
        m_post_method(req, std::move(interface));  
    }
};

// Server类定义保持不变
int main(){
    int ii;
    // 带捕获的lambda可正常传入
    auto get = [&ii](int,  OperatorLike auto intf){ 
        std::string dummy = "dummy";
        std::cout << intf[dummy];
    };
    RestApiImpl api(get); // CTAD正常工作
    
    Server server;
    server.run(api);
    return 0;
}

该方案无任何运行时开销，支持任意可移动构造的回调（包括所有带捕获的lambda、自定义函数对象），是最适配当前场景的解法。如果需要保留RestApiImpl的默认构造能力，可以额外加一个无参构造重载，不需要强制回调类型满足默认构造要求。

方案2：使用类型擦除包装器适配semiregular约束 #

如果必须保留std::semiregular约束、且需要支持默认构造RestApiImpl，可以用std::function对回调做类型擦除包装。注意由于使用的是泛型lambda（参数为OperatorLike auto），需要固定调用签名或自定义泛型类型擦除包装器，简单场景下可以直接指定支持的OperatorLike类型：

// 模板参数默认值设为对应签名的std::function，std::function满足semiregular
template<std::semiregular F = std::function<void(int, Server::impl)>>
class RestApiImpl {
    F m_post_method;
public:
    RestApiImpl(F get = F{}) : m_post_method{std::move(get)} {}
    // apply_post逻辑保持不变
};

int main(){
    int ii;
    auto get = [&ii](int,  OperatorLike auto intf){ 
        std::string dummy = "dummy";
        std::cout << intf[dummy];
    };
    // 把lambda转成对应的std::function传入
    RestApiImpl api(std::function<void(int, Server::impl)>(get));
    // 后续逻辑不变
}

该方案的缺点是类型擦除会带来少量间接调用开销，且泛型场景下适配多OperatorLike类型的成本较高。

方案3：自定义满足semiregular的函数对象 #

如果不想改类模板的约束，也不想引入类型擦除开销，可以把lambda的捕获逻辑封装成自定义函数对象，手动实现semiregular要求的所有语义：

// 自定义函数对象替代带捕获lambda
struct PostHandler {
    int* captured_ii = nullptr; // 用指针存储捕获变量，支持默认构造
    // 手动实现operator()，逻辑和原lambda一致
    void operator()(int, OperatorLike auto intf) const {
        std::string dummy = "dummy";
        std::cout << intf[dummy];
        // 需要访问捕获变量时判空即可
    }
};

int main(){
    int ii;
    PostHandler get{.captured_ii = &ii};
    RestApiImpl<PostHandler> api(get); // PostHandler满足semiregular，可正常实例化
    // 后续逻辑不变
}

该方案零运行时开销，完全符合原有约束，缺点是需要额外写函数对象类型，代码量比直接用lambda稍大。

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