Generics в C++: шаблоны, зачем нужны и как использовать

Введение: Что такое Generics (шаблоны) в C++ и зачем они нужны?

В мире программирования на C++ одной из ключевых концепций, позволяющей писать гибкий, переиспользуемый и типобезопасный код, являются шаблоны (templates). Часто их называют "generics" по аналогии с другими языками, такими как Java или C#, хотя в C++ эта концепция значительно мощнее и глубже.

Представьте, что вам нужно написать функцию для поиска максимального элемента в массиве. Для целых чисел (int) это одна функция, для чисел с плавающей точкой (double) — другая, для строк (std::string) — третья. Без шаблонов вам пришлось бы дублировать код, что ведет к ошибкам и усложнению поддержки.

Generics (шаблоны) решают эту проблему. Они позволяют писать код, который работает с любым типом данных, не жертвуя при этом производительностью (в отличие от виртуальных функций или void*). Шаблоны — это фундамент стандартной библиотеки C++ (STL): контейнеры (std::vector, std::map), алгоритмы (std::sort, std::find) и умные указатели (std::shared_ptr) — все они реализованы с помощью шаблонов.

В этой статье мы разберем, что такое шаблоны в C++, как их правильно объявлять и использовать, а также рассмотрим практические примеры.

Основная часть: Как использовать Generics (шаблоны) в C++

1. Шаблоны функций (Function Templates)

Самый простой способ начать работу с generics — это создать шаблон функции. Вместо того чтобы писать несколько перегруженных версий, вы пишете одну, параметризованную типом.

Синтаксис:

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

Ключевое слово template сообщает компилятору, что это шаблон. <typename T> объявляет параметр типа T. Вы можете использовать class вместо typename — разницы нет.

Пример использования:

#include <iostream>
#include <string>

template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    std::cout << max(10, 20) << std::endl;          // int: 20
    std::cout << max(3.14, 2.71) << std::endl;    // double: 3.14
    std::cout << max(std::string("C++"), std::string("Python")) << std::endl; // string: Python
    return 0;
}

Важно: Компилятор генерирует отдельную версию функции для каждого используемого типа. Это называется инстанцированием шаблона. За счет этого достигается максимальная производительность — нет накладных расходов на виртуальные вызовы.

Несколько параметров типа:

template <typename T1, typename T2>
void printPair(T1 a, T2 b) {
    std::cout << "(" << a << ", " << b << ")" << std::endl;
}
// printPair(1, "hello"); // Выведет: (1, hello)

2. Шаблоны классов (Class Templates)

Шаблоны классов позволяют создавать обобщенные структуры данных. Классический пример — std::vector<T>. Вы можете создать свой собственный шаблонный класс, например, простой стек:

template <typename T>
class Stack {
private:
    T* data;
    size_t size;
    size_t capacity;
public:
    Stack(size_t cap = 10) : size(0), capacity(cap) {
        data = new T[capacity];
    }
    ~Stack() { delete[] data; }

    void push(const T& value) {
        if (size < capacity) {
            data[size++] = value;
        }
    }

    T pop() {
        if (size > 0) {
            return data[--size];
        }
        throw std::out_of_range("Stack is empty");
    }

    bool isEmpty() const { return size == 0; }
};

Использование:

int main() {
    Stack<int> intStack;       // Стек для int
    intStack.push(10);
    intStack.push(20);
    std::cout << intStack.pop() << std::endl; // 20

    Stack<std::string> strStack; // Стек для строк
    strStack.push("Hello");
    strStack.push("World");
    std::cout << strStack.pop() << std::endl; // World

    return 0;
}

Параметры по умолчанию: Шаблоны классов могут иметь параметры по умолчанию, например:

template <typename T = int>
class MyContainer { /* ... */ };
MyContainer<> defaultContainer; // Использует int

3. Специализация шаблонов (Template Specialization)

Иногда общая реализация шаблона не подходит для конкретного типа. Например, если вы хотите, чтобы ваш Stack для bool работал эффективнее (упаковывал биты), или если для const char* нужно изменить логику сравнения.

Полная специализация:

// Общий шаблон
template <typename T>
class Printer {
public:
    void print(const T& value) {
        std::cout << "Generic: " << value << std::endl;
    }
};

// Специализация для типа char
template <>
class Printer<char> {
public:
    void print(const char& value) {
        std::cout << "Char specialization: '" << value << "'" << std::endl;
    }
};

// Использование
Printer<int> p1;
p1.print(42);      // Generic: 42
Printer<char> p2;
p2.print('A');     // Char specialization: 'A'

Специализация — мощный инструмент, но злоупотреблять ей не стоит, так как это усложняет понимание кода.

4. Шаблонные параметры, не явля