C++20 Concepts：检测可变参数成员函数模板及最佳替代方案

核心结论 #

可以通过C++20 Concept结合嵌套模板lambda或SFINAE思路，准确检测类是否存在符合要求的可变参数成员函数模板（或适配mathy_vector<N>的成员函数模板）。如果编译器对某些特性支持有限，也有更兼容的替代方案。

一、正确实现Concept的方案 #

针对你的场景（支持任意长度数值参数调用、任意mathy_vector<N>调用的可组合数学函数类），可以通过嵌套模板lambda在requires表达式中验证成员函数模板的匹配性，无需依赖有限参数的硬编码测试。

完整代码示例

#include <concepts>
#include <type_traits>
#include <utility>

// 示例mathy_vector模板
template<size_t N>
struct mathy_vector {
    double data[N];
};

// 定义可组合数学函数的Concept
template<typename T>
concept ComposableMathFunction = 
    // 验证：支持任意数量的算术类型参数调用
    requires(T func) {
        []<typename... Args>(T& f) requires (std::is_arithmetic_v<Args> && ...) {
            static_assert(std::convertible_to<decltype(f(std::declval<Args>()...)), double>);
        }(func);
    } &&
    // 验证：支持任意长度的mathy_vector调用
    requires(T func) {
        []<size_t N>(T& f) {
            static_assert(std::convertible_to<decltype(f(std::declval<mathy_vector<N>>())), double>);
        }(func);
    };

// 测试用的符合要求的类模板
template<typename InnerFunc>
struct ComposedMathFunc {
    InnerFunc inner;

    // 可变参数算术调用的成员函数模板
    template<typename... Args> requires (std::is_arithmetic_v<Args> && ...)
    double operator()(Args... args) const {
        return inner(args...);
    }

    // mathy_vector调用的成员函数模板
    template<size_t N>
    double operator()(mathy_vector<N> vec) const {
        double sum = 0.0;
        for (size_t i = 0; i < N; ++i) sum += vec.data[i];
        return inner(sum);
    }
};

// 验证Concept生效
static_assert(ComposableMathFunction<ComposedMathFunc<std::plus<double>>>);

原理说明

• 嵌套的模板lambda会尝试推导任意数量的算术类型参数、任意长度的mathy_vector<N>，只要类中存在能匹配的成员函数模板，requires表达式就会返回true。
• static_assert用于确保返回值符合预期（比如转换为double），可根据你的实际需求调整。

二、替代方案（若编译器对嵌套模板支持有限） #

如果你的编译器对嵌套模板lambda的requires支持不完善，可以采用SFINAE特征类+Concept的组合方式，虽然需要手动实现特征类，但兼容性更好：

代码示例

#include <concepts>
#include <type_traits>

template<size_t N>
struct mathy_vector {
    double data[N];
};

// 特征类：检测是否支持mathy_vector<N>调用
template<typename T, size_t N, typename = void>
struct has_vector_call : std::false_type {};

template<typename T, size_t N>
struct has_vector_call<T, N, std::void_t<decltype(std::declval<T>()(std::declval<mathy_vector<N>>()))>> : std::true_type {};

// 特征类：检测是否支持可变参数算术调用
template<typename T, typename... Args>
struct has_variadic_call : std::false_type {};

template<typename T, typename... Args>
struct has_variadic_call<T, Args..., std::void_t<decltype(std::declval<T>()(std::declval<Args>()...))>> : std::true_type {};

// 封装为Concept
template<typename T>
concept ComposableMathFunction = 
    // 检测常用参数数量的可变调用（可根据需求扩展）
    has_variadic_call<T, double>::value &&
    has_variadic_call<T, double, double>::value &&
    has_variadic_call<T, double, double, double>::value &&
    // 检测任意长度的mathy_vector调用
    requires(size_t N) { has_vector_call<T, N>::value; };

说明

• 这种方式通过std::void_t触发SFINAE，判断成员函数是否存在。
• 可变参数部分需要手动列举几种参数数量（比如1、2、3个），虽然无法覆盖绝对任意数量，但在实际场景中足以满足需求。

三、关于标记继承方案的优化 #

你当前使用的继承标记类型方案虽然可行，但不够自动化。如果必须采用类似思路，可以结合CRTP（奇异递归模板模式）减少手动操作：

struct ComposableTag {};

template<typename Derived>
struct ComposableBase : ComposableTag {};

// 使用时只需继承ComposableBase
template<typename InnerFunc>
struct ComposedMathFunc : ComposableBase<ComposedMathFunc<InnerFunc>> {
    // ... 成员函数实现 ...
};

// Concept封装
template<typename T>
concept ComposableMathFunction = std::is_base_of_v<ComposableTag, T>;

这种方式只需让类继承ComposableBase<Derived>，无需手动写ComposableTag，稍微提升了优雅性，但本质还是依赖手动标记，仅作为最后备选。

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