第五节 · 特殊人格 · 模板特例化

C++20 引入的 Concepts 让模板约束更加清晰和易用，大大改善了模板编程的体验和错误信息。

---

为什么需要 Concepts

// 没有 Concepts 时的错误信息难以理解
template<typename T>
T add(T a, T b)
{
    return a + b;
}

struct Foo {};

int main()
{
    add(Foo{}, Foo{});  // 编译错误，但错误信息很长很复杂
    return 0;
}

---

定义 Concept

#include <concepts>

// 简单的 Concept
template<typename T>
concept Numeric = is_arithmetic_v<T>;

// 使用 requires 表达式
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> same_as<T>;  // 要求 a + b 有效且返回 T
};

// 更复杂的约束
template<typename T>
concept Container = requires(T c) {
    typename T::value_type;      // 要求有 value_type 类型
    typename T::iterator;        // 要求有 iterator 类型
    { c.begin() } -> same_as<typename T::iterator>;
    { c.end() } -> same_as<typename T::iterator>;
    { c.size() } -> convertible_to<size_t>;
};

---

使用 Concept

// 方式 1：requires 子句
template<typename T>
requires Numeric<T>
T add(T a, T b)
{
    return a + b;
}

// 方式 2：在模板参数列表中
template<Numeric T>
T subtract(T a, T b)
{
    return a - b;
}

// 方式 3：简写语法（C++20）
Numeric auto multiply(Numeric auto a, Numeric auto b)
{
    return a * b;
}

int main()
{
    cout << add(1, 2) << endl;           // OK
    cout << subtract(5.0, 3.0) << endl;  // OK
    cout << multiply(4, 5) << endl;      // OK
    
    // add("a", "b");  // 错误：string 不满足 Numeric
    return 0;
}

---

标准库 Concepts

#include <concepts>

// 常用 Concepts
template<same_as<int> T>         // 必须是 int
void func1(T) {}

template<derived_from<Base> T>   // 必须继承自 Base
void func2(T) {}

template<convertible_to<int> T>  // 必须可转换为 int
void func3(T) {}

template<integral T>             // 整数类型
void func4(T) {}

template<floating_point T>       // 浮点类型
void func5(T) {}

template<invocable<int> F>       // 可用 int 调用
void func6(F) {}

---

复合 Concepts

// 使用逻辑运算符组合
template<typename T>
concept SignedIntegral = integral<T> && signed_integral<T>;

template<typename T>
concept NumberOrString = Numeric<T> || same_as<T, string>;

// 细化约束
template<typename T>
concept Sortable = requires(T& container) {
    { container.begin() };
    { container.end() };
    requires random_access_iterator<decltype(container.begin())>;
};

---

requires 表达式详解

template<typename T>
concept Printable = requires(T t, ostream& os) {
    // 简单要求：表达式必须有效
    t.toString();
    
    // 类型要求：类型必须存在
    typename T::value_type;
    
    // 复合要求：表达式有效 + 返回类型约束
    { os << t } -> same_as<ostream&>;
    
    // 嵌套要求：额外约束
    requires sizeof(T) > 4;
};

---

基于 Concept 的重载

// 针对不同类型选择不同实现
template<integral T>
T process(T x)
{
    cout << "Integer processing" << endl;
    return x * 2;
}

template<floating_point T>
T process(T x)
{
    cout << "Float processing" << endl;
    return x * 2.0;
}

template<typename T>
requires (!integral<T> && !floating_point<T>)
T process(T x)
{
    cout << "Generic processing" << endl;
    return x;
}

int main()
{
    process(42);      // Integer processing
    process(3.14);    // Float processing
    process("hello"); // Generic processing
    
    return 0;
}

---

实际应用：Iterator Concepts

#include <iterator>

// 使用标准迭代器 concepts
template<input_iterator I, sentinel_for<I> S>
void print_range(I first, S last)
{
    while (first != last)
    {
        cout << *first << " ";
        ++first;
    }
    cout << endl;
}

template<forward_iterator I>
void advance_twice(I& it)
{
    ++it;
    ++it;
}

template<random_access_iterator I>
void jump(I& it, int n)
{
    it += n;  // 只有随机访问迭代器才支持
}

int main()
{
    vector<int> v = {1, 2, 3, 4, 5};
    print_range(v.begin(), v.end());
    
    auto it = v.begin();
    jump(it, 3);
    cout << *it << endl;  // 4
    
    return 0;
}

---

自定义类型满足 Concept

template<typename T>
concept Drawable = requires(T t) {
    { t.draw() } -> same_as<void>;
    { t.getColor() } -> convertible_to<string>;
};

class Circle
{
public:
    void draw() { cout << "Drawing circle" << endl; }
    string getColor() const { return "red"; }
};

class Rectangle
{
public:
    void draw() { cout << "Drawing rectangle" << endl; }
    const char* getColor() const { return "blue"; }  // 可转换为 string
};

template<Drawable T>
void render(T& shape)
{
    cout << "Color: " << shape.getColor() << endl;
    shape.draw();
}

int main()
{
    Circle c;
    Rectangle r;
    
    render(c);
    render(r);
    
    return 0;
}

---

Concept 提升错误信息

template<typename T>
concept Hashable = requires(T t) {
    { hash<T>{}(t) } -> convertible_to<size_t>;
};

template<Hashable T>
size_t computeHash(const T& value)
{
    return hash<T>{}(value);
}

struct MyType {};  // 没有定义 hash

int main()
{
    computeHash(42);        // OK
    computeHash("hello"s);  // OK
    // computeHash(MyType{});  // 错误信息：MyType 不满足 Hashable
    
    return 0;
}

---

习题

• 定义一个 Serializable concept，要求类型有 serialize() 和 deserialize() 方法。

• 使用 concepts 重写一个泛型排序函数，要求元素可比较。

• 解释 concepts 相比 SFINAE 的优势。