Шаблоны в C++: основы и продвинутые паттерны

1template <typename T>
2T max_val(T a, T b) {
3    return (a > b) ? a : b;
4}
5
6int main() {
7    std::cout << max_val(3, 7) << "\n";     // 7
8    std::cout << max_val(3.14, 2.71) << "\n"; // 3.14
9    std::cout << max_val('a', 'z') << "\n";  // z
10}

1// Общий шаблон
2template <typename T>
3class Printer {
4public:
5    void print(T value) {
6        std::cout << "Value: " << value << "\n";
7    }
8};
9
10// Частичная специализация для указателей
11template <typename T>
12class Printer<T*> {
13public:
14    void print(T* value) {
15        if (value) {
16            std::cout << "Pointer to: " << *value << "\n";
17        } else {
18            std::cout << "Null pointer\n";
19        }
20    }
21};

1template <typename T, size_t N>
2class FixedArray {
3    T data[N];
4    size_t count = 0;
5public:
6    void push(const T& value) {
7        if (count < N) {
8            data[count++] = value;
9        }
10    }
11    
12    T& operator[](size_t index) { return data[index]; }
13    const T& operator[](size_t index) const { return data[index]; }
14    
15    size_t size() const { return count; }
16    constexpr size_t capacity() const { return N; }
17};
18
19FixedArray<int, 10> arr;
20arr.push(1);
21arr.push(2);

1// Рекурсивный вариант
2void print() {} // Базовый случай
3
4template <typename T, typename... Args>
5void print(const T& first, const Args&... rest) {
6    std::cout << first << " ";
7    print(rest...);
8}
9
10// Fold expressions (C++17)
11template <typename... Args>
12void print_all(const Args&... args) {
13    ((std::cout << args << " "), ...);
14}
15
16int main() {
17    print(1, "hello", 3.14, 'c'); // 1 hello 3.14 c
18    print_all(1, "hello", 3.14);  // 1 hello 3.14
19}

1template <typename T>
2void wrapper(T&& arg) {
3    // arg — forwarding reference
4    process(std::forward<T>(arg));
5}

1template <typename T>
2typename std::enable_if<std::is_integral<T>::value, T>::type
3safe_divide(T a, T b) {
4    if (b == 0) throw std::runtime_error("Division by zero");
5    return a / b;
6}
7
8// Только для целочисленных типов
9safe_divide(10, 3);    // OK
10safe_divide(10.0, 3.0); // Ошибка компиляции

1template <typename T>
2auto process(T value) {
3    if constexpr (std::is_same_v<T, std::string>) {
4        return value + " processed";
5    } else if constexpr (std::is_arithmetic_v<T>) {
6        return value * 2;
7    } else {
8        return value;
9    }
10}

1template <typename T>
2concept Numeric = std::is_arithmetic_v<T>;
3
4template <Numeric T>
5T square(T value) {
6    return value * value;
7}
8
9// Или с requires
10template <typename T>
11requires std::is_integral_v<T>
12T factorial(T n) {
13    return n <= 1 ? 1 : n * factorial(n - 1);
14}

1// Вычисление факториала на этапе компиляции
2template <size_t N>
3struct Factorial {
4    static constexpr size_t value = N * Factorial<N - 1>::value;
5};
6
7template <>
8struct Factorial<0> {
9    static constexpr size_t value = 1;
10};
11
12static_assert(Factorial<5>::value == 120);