第三节 · 原地不动 · 深入理解移动操作

模板元编程是利用模板在编译期进行计算的技术。虽然复杂，但能带来零运行时开销的抽象。

---

编译期计算

// 编译期阶乘
template<int N>
struct Factorial
{
    static const int value = N * Factorial<N - 1>::value;
};

// 特化作为递归终止条件
template<>
struct Factorial<0>
{
    static const int value = 1;
};

int main()
{
    // 编译期计算，运行期直接使用结果
    cout << Factorial<5>::value << endl;   // 120
    cout << Factorial<10>::value << endl;  // 3628800
    
    // 可以用作数组大小
    int arr[Factorial<4>::value];  // int arr[24]
    
    return 0;
}

---

类型计算

// 移除指针
template<typename T>
struct RemovePointer
{
    using type = T;
};

template<typename T>
struct RemovePointer<T*>
{
    using type = T;
};

// 使用
int main()
{
    RemovePointer<int*>::type a = 42;      // int a
    RemovePointer<double**>::type b = nullptr;  // double* b
    
    cout << typeid(a).name() << endl;  // int
    
    return 0;
}

---

条件类型

// 类似于三元运算符的类型版本
template<bool Condition, typename Then, typename Else>
struct If
{
    using type = Then;
};

template<typename Then, typename Else>
struct If<false, Then, Else>
{
    using type = Else;
};

// 使用
int main()
{
    If<(sizeof(int) > 4), long, int>::type big;
    If<true, string, int>::type str;
    
    str = "hello";
    cout << str << endl;
    
    return 0;
}

---

类型列表

// 类型列表
template<typename... Types>
struct TypeList {};

// 获取第一个类型
template<typename List>
struct Front;

template<typename Head, typename... Tail>
struct Front<TypeList<Head, Tail...>>
{
    using type = Head;
};

// 获取大小
template<typename List>
struct Size;

template<typename... Types>
struct Size<TypeList<Types...>>
{
    static const size_t value = sizeof...(Types);
};

int main()
{
    using MyList = TypeList<int, double, string>;
    
    Front<MyList>::type x = 42;  // int x
    cout << Size<MyList>::value << endl;  // 3
    
    return 0;
}

---

SFINAE 进阶

// 检测类型是否有特定成员
template<typename T, typename = void>
struct HasSize : false_type {};

template<typename T>
struct HasSize<T, void_t<decltype(declval<T>().size())>> : true_type {};

// 使用
template<typename T>
void printInfo(const T& x)
{
    if constexpr (HasSize<T>::value)
    {
        cout << "Size: " << x.size() << endl;
    }
    else
    {
        cout << "No size method" << endl;
    }
}

int main()
{
    vector<int> v = {1, 2, 3};
    int n = 42;
    
    printInfo(v);  // Size: 3
    printInfo(n);  // No size method
    
    return 0;
}

---

编译期字符串

// 固定大小的编译期字符串
template<size_t N>
struct FixedString
{
    char data[N];
    
    constexpr FixedString(const char (&str)[N])
    {
        for (size_t i = 0; i < N; ++i)
            data[i] = str[i];
    }
    
    constexpr size_t size() const { return N - 1; }
    constexpr char operator[](size_t i) const { return data[i]; }
};

template<FixedString Str>
struct StringWrapper
{
    static void print()
    {
        cout << Str.data << endl;
    }
};

int main()
{
    StringWrapper<"Hello">::print();  // Hello (C++20)
    return 0;
}

---

constexpr if（C++17）

template<typename T>
string stringify(const T& x)
{
    if constexpr (is_same_v<T, string>)
    {
        return x;  // 已经是字符串
    }
    else if constexpr (is_arithmetic_v<T>)
    {
        return to_string(x);  // 数字转字符串
    }
    else if constexpr (is_pointer_v<T>)
    {
        if (x == nullptr)
            return "null";
        return stringify(*x);  // 递归解引用
    }
    else
    {
        return "unknown";
    }
}

int main()
{
    cout << stringify(42) << endl;        // 42
    cout << stringify(3.14) << endl;      // 3.140000
    cout << stringify("hello"s) << endl;  // hello
    
    int n = 100;
    cout << stringify(&n) << endl;        // 100
    
    return 0;
}

---

concept（C++20）

// 定义概念
template<typename T>
concept Numeric = is_arithmetic_v<T>;

template<typename T>
concept Printable = requires(T t) {
    { cout << t } -> same_as<ostream&>;
};

// 使用概念约束模板
template<Numeric T>
T add(T a, T b)
{
    return a + b;
}

template<Printable T>
void print(const T& x)
{
    cout << x << endl;
}

int main()
{
    cout << add(1, 2) << endl;      // OK
    cout << add(1.5, 2.5) << endl;  // OK
    // add("a", "b");  // 错误：string 不是 Numeric
    
    print(42);      // OK
    print("hello"); // OK
    
    return 0;
}

---

实际应用：单位系统

// 编译期保证单位正确
template<int M, int L, int T>  // 质量、长度、时间的幂次
struct Unit
{
    double value;
    
    explicit Unit(double v) : value(v) {}
};

// 类型别名
using Mass = Unit<1, 0, 0>;      // kg
using Length = Unit<0, 1, 0>;    // m
using Time = Unit<0, 0, 1>;      // s
using Velocity = Unit<0, 1, -1>; // m/s
using Force = Unit<1, 1, -2>;    // kg·m/s² = N

// 乘法
template<int M1, int L1, int T1, int M2, int L2, int T2>
Unit<M1+M2, L1+L2, T1+T2> operator*(Unit<M1, L1, T1> a, Unit<M2, L2, T2> b)
{
    return Unit<M1+M2, L1+L2, T1+T2>(a.value * b.value);
}

int main()
{
    Mass m(10);      // 10 kg
    Velocity v(5);   // 5 m/s
    
    // auto f = m * v;  // 类型是 Unit<1, 1, -1>，不是力！
    // 编译期类型检查
    
    return 0;
}

---

习题

• 实现一个编译期斐波那契数列计算。

• 使用 SFINAE 检测类型是否可迭代。

• 用 concept 定义一个"容器"的约束条件。