自定义概念定义 ​

为什么需要自定义概念 ​

标准库提供的概念覆盖了通用的类型分类(整数、浮点、可复制、可比较等),但实际项目中你常常需要更具体的约束——比如"类型必须有 serialize() 方法""类型必须同时支持加法和乘法""类型必须是一个容器并且元素类型是整数"等。这些需求需要你自己定义概念。

自定义概念的核心思路:用标准概念、类型特征和 requires 表达式作为构建块,通过逻辑组合拼出你需要的约束条件。

定义语法 ​

cpp
template<模板参数列表>
concept 概念名 = 约束表达式;

约束表达式可以是以下几种形式或它们的组合:

  • 标准概念或其他自定义概念
  • std::is_xxx_v<T> 等类型特征
  • requires 表达式
  • 用 && 和 || 组合的复合条件

基本示例 ​

cpp
#include <iostream>
#include <concepts>
#include <string>
#include <vector>
#include <type_traits>
#include <cmath>

// ============================
// 示例1:基于类型特征定义概念
// ============================

// 算术类型(整数或浮点)
template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

// 枚举类型
template<typename T>
concept Enumeration = std::is_enum_v<T>;

// 指针类型
template<typename T>
concept Pointer = std::is_pointer_v<T>;

// 非引用类型
template<typename T>
concept NonReference = !std::is_reference_v<T>;

template<Arithmetic T>
T multiply(T a, T b) {
    return a * b;
}

void type_trait_concept_demo() {
    std::cout << multiply(3, 4) << std::endl;        // 12
    std::cout << multiply(2.5, 3.0) << std::endl;    // 7.5
    // multiply(std::string("a"), std::string("b")); // 编译错误
}

// ============================
// 示例2:基于 requires 表达式定义概念
// ============================

// 可序列化:要求有 serialize() 和 deserialize() 方法
template<typename T>
concept Serializable = requires(T obj, std::string data) {
    { obj.serialize() } -> std::convertible_to<std::string>;
    { T::deserialize(data) } -> std::same_as<T>;
};

// 可打印:要求可以用 << 输出到 ostream
template<typename T>
concept Printable = requires(std::ostream& os, const T& value) {
    { os << value } -> std::same_as<std::ostream&>;
};

// 容器:要求有 begin/end/size/push_back
template<typename T>
concept PushBackContainer = requires(T c, typename T::value_type v) {
    typename T::value_type;
    typename T::iterator;
    { c.begin() } -> std::same_as<typename T::iterator>;
    { c.end() } -> std::same_as<typename T::iterator>;
    { c.size() } -> std::convertible_to<std::size_t>;
    c.push_back(v);
};

// 测试 Serializable
struct Config {
    std::string name;
    int value;

    std::string serialize() const {
        return name + "=" + std::to_string(value);
    }

    static Config deserialize(const std::string& data) {
        auto pos = data.find('=');
        return Config{data.substr(0, pos), std::stoi(data.substr(pos + 1))};
    }
};

template<Serializable T>
void save(const T& obj) {
    std::string data = obj.serialize();
    std::cout << "保存: " << data << std::endl;
}

void requires_concept_demo() {
    Config cfg{"timeout", 30};
    save(cfg);   // Config 满足 Serializable
    // save(42); // int 不满足 Serializable,编译错误
}

// ============================
// 示例3:组合已有概念
// ============================

// 数值类型:整数或浮点
template<typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

// 有符号数值:有符号整数或浮点
template<typename T>
concept SignedNumeric = (std::integral<T> && std::is_signed_v<T>)
                     || std::floating_point<T>;

// 可排序的容器:是容器 + 元素支持全序比较
template<typename T>
concept SortableContainer = PushBackContainer<T>
    && std::totally_ordered<typename T::value_type>;

// 正则数值:是数值 + 支持相等比较 + 可默认构造
template<typename T>
concept RegularNumeric = Numeric<T>
    && std::equality_comparable<T>
    && std::default_initializable<T>;

template<SignedNumeric T>
T absolute(T value) {
    return value < T(0) ? -value : value;
}

void composition_demo() {
    std::cout << absolute(-42) << std::endl;    // 42
    std::cout << absolute(-3.14) << std::endl;  // 3.14
    // absolute(42u);   // unsigned int 不满足 SignedNumeric,编译错误
}

// ============================
// 示例4:多参数概念
// ============================

// 两个类型可以相加,结果可以转换为 Result
template<typename T, typename U, typename Result = T>
concept AddableTo = requires(T a, U b) {
    { a + b } -> std::convertible_to<Result>;
};

// 两个类型之间可以互相转换
template<typename From, typename To>
concept BidirectionallyConvertible =
    std::convertible_to<From, To> && std::convertible_to<To, From>;

template<typename T, typename U>
    requires AddableTo<T, U>
auto safe_add(T a, U b) {
    return a + b;
}

void multi_param_demo() {
    std::cout << safe_add(3, 4.5) << std::endl;    // 7.5
    std::cout << safe_add(std::string("hi "), std::string("there")) << std::endl;
}

// ============================
// 示例5:用概念约束类的成员函数
// ============================

template<typename T>
class SmartContainer {
    std::vector<T> data_;
public:
    void add(const T& item) {
        data_.push_back(item);
    }

    // 只有 T 支持 << 时才存在 print()
    void print() const requires Printable<T> {
        for (const auto& item : data_) {
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }

    // 只有 T 支持全序比较时才存在 sort()
    void sort() requires std::totally_ordered<T> {
        std::sort(data_.begin(), data_.end());
    }

    // 只有 T 是算术类型时才存在 sum()
    T sum() const requires Arithmetic<T> {
        T total = T(0);
        for (const auto& item : data_) {
            total += item;
        }
        return total;
    }

    std::size_t size() const { return data_.size(); }
};

void conditional_member_demo() {
    SmartContainer<int> ic;
    ic.add(3);
    ic.add(1);
    ic.add(4);
    ic.sort();          // int 支持比较,sort() 存在
    ic.print();         // int 支持 <<,print() 存在
    std::cout << "总和: " << ic.sum() << std::endl;  // int 是算术类型

    SmartContainer<std::string> sc;
    sc.add("hello");
    sc.add("world");
    sc.print();         // string 支持 <<
    sc.sort();          // string 支持比较
    // sc.sum();        // string 不是算术类型,sum() 不存在,编译错误
}

int main() {
    std::cout << "=== 类型特征概念 ===" << std::endl;
    type_trait_concept_demo();

    std::cout << "\n=== requires 概念 ===" << std::endl;
    requires_concept_demo();

    std::cout << "\n=== 组合概念 ===" << std::endl;
    composition_demo();

    std::cout << "\n=== 多参数概念 ===" << std::endl;
    multi_param_demo();

    std::cout << "\n=== 条件成员函数 ===" << std::endl;
    conditional_member_demo();

    return 0;
}

自定义概念的设计模式 ​

接口概念 ​

描述类型必须提供的方法集合,类似 Java/C# 的接口:

cpp
// 要求类型实现"可绘制"接口
template<typename T>
concept Drawable = requires(T obj, int x, int y) {
    obj.draw();
    obj.move(x, y);
    { obj.visible() } -> std::convertible_to<bool>;
};

语义概念 ​

基于标准概念组合,表达更高层的语义:

cpp
// "值类型":可以复制、比较、哈希
template<typename T>
concept ValueType = std::regular<T> && requires(T a) {
    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};

层次化概念 ​

从简单到复杂逐层构建:

cpp
template<typename T>
concept HasSize = requires(T c) {
    { c.size() } -> std::convertible_to<std::size_t>;
};

template<typename T>
concept Iterable = requires(T c) {
    c.begin();
    c.end();
};

template<typename T>
concept SizedIterable = HasSize<T> && Iterable<T>;

template<typename T>
concept ResizableContainer = SizedIterable<T> && requires(T c, std::size_t n) {
    c.resize(n);
    c.clear();
    { c.empty() } -> std::convertible_to<bool>;
};

适用场景 ​

  • 定义库的公共 API 对类型的要求
  • 为泛型数据结构约束元素类型
  • 条件性地启用或禁用类模板的成员函数
  • 替代 SFINAE 和 enable_if 来进行编译时类型分派
  • 在大型项目中用概念文档化类型的接口约定

常见问题 ​

自定义概念应该放在哪里?

概念必须定义在命名空间作用域。通常和使用它们的模板放在同一个头文件中,或者集中定义在一个 concepts.h 头文件中供多处引用。

概念的名字用什么风格?

标准库用小写下划线(same_as、totally_ordered)。很多项目用大驼峰(Serializable、Drawable)来区分自定义概念和标准概念。关键是团队保持一致。

概念可以用 ! 取反吗?

可以在约束表达式中用 !,但取反后的概念不参与包含(subsumption)关系。也就是说,!ConceptA 在重载决议中不会被认为比 ConceptB 更具体或更通用。

概念定义中可以用 constexpr 函数吗?

可以。任何编译期求值为 bool 的表达式都可以作为概念的约束条件,包括 constexpr 函数调用。

注意事项 ​

  • 概念应该表达有意义的语义分类,而不只是语法检查
  • 优先组合标准概念,不要从头写已有的约束
  • 避免定义过于宽泛或过于狭窄的概念
  • 概念不能递归定义
  • 概念不能特化
  • 用 && 组合的概念比单个概念更"具体",会在重载决议中优先匹配
  • 用 requires 约束类的成员函数时,不满足约束的成员函数会从类中"消失"(SFINAE 效果)

编译器支持情况 ​

编译器最低支持版本
GCC10.0
Clang10.0
MSVC19.26 (VS 2019 16.6)

总结 ​

自定义概念让你可以为自己的项目定义精确的类型约束。定义方式很灵活:可以基于类型特征(std::is_xxx_v)、requires 表达式、标准概念的组合,或者三者的混合。设计概念时应该表达有意义的语义分类("可序列化""可绘制""值类型"),而不只是机械地列举语法要求。概念还可以分层构建——从基础概念组合出复杂概念,形成清晰的层次结构。用 requires 约束类的成员函数,可以让类根据模板参数的不同自动"有"或"没有"某些方法,这是一种比 SFINAE 更简洁的条件成员技术。