C++ Concepts校验可变参数包类型匹配指定类型的报错问题

问题根因 #

你对C++20 concept缩写语法的参数传递规则理解存在偏差：
当使用Concept<固定参数> auto 形参的缩写形式时，编译器会将单个形参的推导类型作为Concept的第一个模板参数传入，尖括号内填写的固定参数会依次作为Concept的后续模板参数。如果形参是参数包（auto&&... objects），编译器会对参数包中的每个类型单独执行Concept校验——即每个类型依次作为Concept的第一个参数参与约束判断，而非将整个类型包作为第一个参数传入。
你定义的all_types_are和all_types_in两个concept，将待校验的类型包放在了第一个模板参数位置，手动传入的目标类型/类型列表放在后续位置，直接导致参数匹配完全错位，约束永远无法满足。同时这两个concept内的折叠表达式逻辑也存在顺序错误，即使调整参数顺序也无法得到正确的判断结果。

修正方案 #

推荐方案：直接复用单类型约束，无需额外定义参数包级concept #

由于缩写语法会自动对参数包内的每个元素逐个应用约束，你已经实现的type_is和type_in完全可以直接用于参数包约束，不需要单独编写all_types_*系列concept，代码最简洁且不易出错：

// 约束所有参数都匹配A类型
auto method3(type_is<A> auto&&... objects)
{
    (std::cout << ... << objects.var);
    std::cout << std::endl;
}

// 约束所有参数都属于A/B类型列表
auto method4(type_in<A, B> auto&&... objects)
{
    (std::cout << ... << objects.var);
    std::cout << std::endl;
}

可选方案：保留独立参数包级concept #

如果你确实需要单独定义参数包级的约束（比如用于requires子句的复现场景），需要调整模板参数顺序、修正折叠逻辑。注意这种写法的concept需要配合普通模板的requires子句使用，无法直接用于缩写语法：

// 校验类型包中所有类型都匹配目标类型
template <typename TargetType, typename ...Ts>
concept all_types_are = (std::same_as<std::remove_cvref_t<Ts>, TargetType> && ...);

// 校验类型包中所有类型都属于允许的类型列表
template <typename ...AllowedTypes, typename ...Ts>
concept all_types_in = ((std::same_as<std::remove_cvref_t<Ts>, AllowedTypes> || ...) && ...);

// 使用时需要显式声明模板参数，通过requires引入约束
template <typename... Ts>
requires all_types_are<A, Ts...>
auto method3(Ts&&... objects)
{
    (std::cout << ... << objects.var) << std::endl;
}

template <typename... Ts>
requires all_types_in<A, B, Ts...>
auto method4(Ts&&... objects)
{
    (std::cout << ... << objects.var) << std::endl;
}

完整可运行代码 #

#include <concepts>
#include <iostream>
#include <type_traits>


class A{public: int var = 100;};
class B{public: int var = 200;};
class C{public: int var = 300;};


template <typename TypeToCheck, typename TypeToCheckAgainst>
concept type_is = std::same_as<std::remove_cvref_t<TypeToCheck>, TypeToCheckAgainst>;


template <typename TypeToCheck, typename ...TypesToCheckAgainst>
concept type_in = (std::same_as<std::remove_cvref_t<TypeToCheck>, TypesToCheckAgainst> || ...);


auto method1(type_is<A> auto&& object)
{
    std::cout << object.var << std::endl;
}


auto method2(type_in<A, B> auto&& object)
{
    std::cout << object.var << std::endl;
}


auto method3(type_is<A> auto&&... objects)
{
    (std::cout << ... << objects.var) << std::endl;
}


auto method4(type_in<A, B> auto&&... objects)
{
    (std::cout << ... << objects.var) << std::endl;
}


int main()
{
    A a;
    B b;
    C c;

    method1(a);       // 输出100
    method2(b);       // 输出200
    method3(a, a, a); // 输出100100100
    method4(a, b, b); // 输出100200200

    // 以下调用会按预期触发编译约束报错
    // method1(b);
    // method2(c);
    // method3(a, b);
    // method4(a, c);

    return 0;
}

注：原代码中concept里多余的requires嵌套可以直接省略，不影响约束效果，代码可以更简洁。

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