C++：如何增强std::function赋值的类型安全性？

要实现严格匹配std::function的参数签名（禁止将值参数函数赋值给const引用参数的function类型），可以通过以下两种方案实现，完全符合你的限制条件（无需移除拷贝构造、无需全局修改类）：

方案一：自定义StrictFunction包装类（兼容C++11+） #

std::function的宽松匹配源于它允许隐式转换参数，我们可以实现一个仅接受签名完全匹配的包装类，通过模板元编程在编译期校验签名一致性。

实现代码 #

#include <functional>
#include <type_traits>

// 辅助模板：提取可调用对象的签名
template<typename T>
struct function_signature;

// 针对std::function的特化
template<typename R, typename... Args>
struct function_signature<std::function<R(Args...)>> {
    using type = R(Args...);
};

// 针对函数指针的特化
template<typename R, typename... Args>
struct function_signature<R(*)(Args...)> {
    using type = R(Args...);
};

// 自定义严格匹配的函数包装类
template<typename Signature>
class StrictFunction;

template<typename R, typename... Args>
class StrictFunction<R(Args...)> {
private:
    std::function<R(Args...)> inner_func;

public:
    // 仅接受签名完全匹配的可调用对象
    template<typename F>
    StrictFunction(F&& func, 
                   typename std::enable_if<
                       std::is_same_v<
                           typename function_signature<typename std::decay<F>::type>::type,
                           R(Args...)
                       >
                   >::type* = nullptr) 
        : inner_func(std::forward<F>(func)) {}

    // 重载调用运算符
    R operator()(Args... args) const {
        return inner_func(std::forward<Args>(args)...);
    }
};

应用到你的示例 #

#include <iostream>

class Thing {
public:
    Thing(int count) : count_(count) {}
    int count_;
};

// 替换原有的std::function别名
using ConstByRefFunction = StrictFunction<void(const Thing&)>;

void DoThingByValue(Thing event) { event.count_ += 5; }
void DoThingByRef(const Thing& event) { /* 符合预期签名的函数 */ }

int main() {
    Thing thing(95);
    // ConstByRefFunction func = DoThingByValue; // 编译报错：无法匹配构造函数
    ConstByRefFunction func = DoThingByRef; // 正常通过编译
    func(thing);
    std::cout << thing.count_ << std::endl;
    return 0;
}

该方案通过std::is_same_v严格校验可调用对象的签名与目标签名是否完全一致，不匹配的赋值会直接触发编译错误。

方案二：C++20 Concepts（更简洁） #

若项目支持C++20，可直接用Concepts约束可调用对象的签名，实现更简洁的校验：

实现代码 #

#include <functional>
#include <concepts>
#include <type_traits>

// 复用之前的function_signature辅助模板
template<typename T>
struct function_signature;

template<typename R, typename... Args>
struct function_signature<std::function<R(Args...)>> {
    using type = R(Args...);
};

template<typename R, typename... Args>
struct function_signature<R(*)(Args...)> {
    using type = R(Args...);
};

// 定义Concept：检查可调用对象签名是否匹配目标
template<typename F, typename Signature>
concept matches_exact_signature = std::is_same_v<
    typename function_signature<typename std::decay<F>::type>::type,
    Signature
>;

// 带约束的构造函数包装
template<typename Signature, typename F>
requires matches_exact_signature<F, Signature>
std::function<Signature> make_strict_function(F&& func) {
    return std::function<Signature>(std::forward<F>(func));
}

应用到你的示例 #

int main() {
    Thing thing(95);
    // auto func = make_strict_function<void(const Thing&)>(DoThingByValue); // 编译报错
    auto func = make_strict_function<void(const Thing&)>(DoThingByRef); // 正常通过
    func(thing);
    return 0;
}

Concepts会在编译期直接拦截签名不匹配的赋值，代码更简洁易读。

方案总结 #

• 两种方案均无需修改Thing类的拷贝构造函数，也无需全局添加额外方法，完全针对std::function赋值场景解决问题。
• 若项目不支持C20，优先选择自定义包装类方案，兼容C11及以上版本。
• 所有校验均在编译阶段完成，无需依赖代码审查，彻底避免隐式拷贝的意外触发。

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