利用Concepts避免代码重复：该方案是否存在隐患及解决办法？

你当前的写法确实能在简单场景下避免重复，但存在以下几个隐患：

隐患分析 #

1. 过度放宽类型约束，引发无意义编译错误
   你的no_repetition concept仅检查移除cv和引用后的类型是否为int，这会允许volatile int、const volatile int等类型进入test函数。但这些类型无法匹配f的现有重载（volatile int&不能绑定到const int&，也不能转换为int&&），最终会在函数体中触发编译错误，错误信息不够直观。

2. 无法支持可隐式转换到int的类型
   像short、char这类可以隐式转换为int的类型，会被你的concept直接拒绝，但实际上它们完全可以调用f的重载（比如short右值会转换为int&&，左值会绑定到const int&），限制了函数的通用性。

3. Concept语义模糊且冗余
   no_repetition这个命名没有清晰表达约束意图，且写法可以更简化，没必要用双模板参数的concept。

解决方法 #

针对这些问题，推荐两种更稳健的写法：

方法一：直接用requires表达式约束参数可转发给f #

这种方式让编译器自动检查参数是否能合法调用f，既保证兼容性，又能提前给出清晰的错误提示：

#include <print>
#include <utility>

void f(int&&) {
    std::println("&& overload");
}
void f(int const&) {
    std::println("const& overload");
}

template<typename T>
requires requires(T&& val) {
    // 检查转发后的参数能否调用f
    f(std::forward<T>(val));
}
void test(T&& val) {
    f(std::forward<T>(val));
}

int main() {
    int lval = 0;
    test(0);          // 输出 && overload
    test(lval);       // 输出 const& overload
    short s = 1;
    test(s);          // 输出 const& overload（short左值隐式转换为const int&）
    test(static_cast<short>(2)); // 输出 && overload（short右值隐式转换为int&&）
    // volatile int vval = 0;
    // test(vval); // 编译报错，且错误提示会明确指出无法调用f
    return 0;
}

方法二：精准限定int的合法cv/引用变体 #

如果你确实只想接受int及其标准cv/引用类型（不包含volatile），可以定义更精准的concept：

#include <type_traits>
#include <print>
#include <utility>

void f(int&&) {
    std::println("&& overload");
}
void f(int const&) {
    std::println("const& overload");
}

template<typename T>
concept valid_int_type = 
    std::same_as<std::remove_cv_t<std::remove_reference_t<T>>, int> &&
    (std::is_same_v<T, int> ||
     std::is_same_v<T, int&> ||
     std::is_same_v<T, const int&> ||
     std::is_same_v<T, int&&> ||
     std::is_same_v<T, const int&&>);

void test(valid_int_type auto&& val) {
    f(std::forward<decltype(val)>(val));
}

int main() {
    int lval = 0;
    test(0);          // 输出 && overload
    test(lval);       // 输出 const& overload
    const int clval = 1;
    test(clval);      // 输出 const& overload
    test(std::move(clval)); // 输出 const& overload（const int&&绑定到const int&）
    return 0;
}

额外提示 #

如果不需要提前的约束检查，甚至可以直接写无约束的完美转发模板，依靠编译器在函数体中进行重载决议：

#include <print>
#include <utility>

void f(int&&) {
    std::println("&& overload");
}
void f(int const&) {
    std::println("const& overload");
}

template<typename T>
void test(T&& val) {
    f(std::forward<T>(val));
}

这种写法最简洁，但错误提示会出现在函数体内部，不如带requires的版本直观。

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