模板与泛型

template <typename T>
T add(T a, T b) {
    return a + b;
}

add<int>(1, 2);          // 3
add(1.0, 2.0);           // 推断 double
add(std::string("a"), std::string("b"));

template <typename T, typename U>
auto sum(T a, U b) -> decltype(a + b) {     // C++11 后置返回
    return a + b;
}

// C++14 起可省略 trailing return
template <typename T, typename U>
auto sum(T a, U b) { return a + b; }

template <typename T, size_t N>
struct Array {
    T data[N];
    constexpr size_t size() const { return N; }
};

Array<int, 10> a;

template <typename T>
class Stack {
public:
    void push(const T& v) { data_.push_back(v); }
    T pop() {
        T v = data_.back();
        data_.pop_back();
        return v;
    }
private:
    std::vector<T> data_;
};

Stack<int> s;
s.push(1);

template <typename T>
struct TypeName { static const char* get() { return "unknown"; } };

template <>
struct TypeName<int> { static const char* get() { return "int"; } };

template <>
struct TypeName<double> { static const char* get() { return "double"; } };

TypeName<int>::get();     // "int"
TypeName<float>::get();   // "unknown"

template <typename T>
struct Vector { /* general */ };

template <typename T>
struct Vector<T*> { /* pointer specialization */ };

template <typename... Args>
void log(Args... args) {
    (std::cout << ... << args) << '\n';      // C++17 fold
}

log(1, " ", 2.0, " ", "x");

#include <concepts>

template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template <Numeric T>
T add(T a, T b) { return a + b; }

// 简写
auto add2(Numeric auto a, Numeric auto b) { return a + b; }

template <typename T>
requires std::integral<T>
T gcd(T a, T b) { ... }

template <typename T,
          typename = std::enable_if_t<std::is_integral_v<T>>>
T half(T x) { return x / 2; }

template <int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template <>
struct Factorial<0> {
    static constexpr int value = 1;
};

Factorial<5>::value;      // 120

constexpr int fact(int n) {
    return n <= 1 ? 1 : n * fact(n - 1);
}