⚙️ C++

Дженерики и параметрические типы в C++: подробное руководство

Урок 28 / 39 • Полная теория для чтения

Что это такое и зачем? (аналогия из реальной жизни)

Представьте, что вы — владелец небольшого склада. К вам приходят разные люди и просят хранить их вещи. Один приносит коробку с книгами, другой — ящик с инструментами, третий — мешок с яблоками. Что вы сделаете? Построите отдельный склад для книг, отдельный для инструментов и отдельный для яблок? Это было бы очень неудобно и дорого.

Вместо этого вы строите один универсальный склад, который может хранить что угодно. Вы просто говорите: «Приносите ваши вещи, я положу их на полку. Мне всё равно, что это — книги, инструменты или яблоки. Главное, чтобы вы потом забрали то же самое, что принесли». Это и есть идея дженериков (обобщённых типов) в программировании.

В C++ дженерики позволяют нам писать один класс или функцию, которые могут работать с любым типом данных: целыми числами, дробями, строками, вашими собственными классами — с чем угодно. Вместо того чтобы писать отдельную функцию для сложения целых чисел, отдельную для сложения дробей и отдельную для сложения строк (что было бы кошмаром), мы пишем одну обобщённую функцию, которая умеет складывать всё, что можно сложить.

Важно: Дженерики не стирают типы (как в Java или Python), а создают новую версию функции или класса для каждого типа, с которым вы их используете. Это называется шаблоны (templates) в C++. Компилятор сам генерирует нужный код.

Давайте посмотрим на жизненный пример. У вас есть коробка. Вы можете положить в неё яблоко, и тогда это «коробка для яблок». Или вы можете положить в неё книгу, и тогда это «коробка для книг». Но сама коробка — одна и та же. В C++ мы бы написали Box<Apple> или Box<Book>. Угловые скобки — это и есть способ сказать компилятору: «Сделай мне коробку, которая будет хранить именно яблоки».

Теория: как это работает изнутри

Чтобы понять дженерики, нужно заглянуть «под капот» компилятора. Когда вы пишете:

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

Компилятор не создаёт никакого кода сразу. Он просто запоминает: «У меня есть заготовка (шаблон) для функции max». Когда вы в коде пишете:

int result = max(5, 10);

Компилятор смотрит: «Ага, типы аргументов — int. Значит, нужно создать функцию max, где T = int». И он генерирует такой код:

int max(int a, int b) {
    return (a > b) ? a : b;
}

Если вы потом напишете:

double result2 = max(3.14, 2.71);

Компилятор сгенерирует ещё одну функцию:

double max(double a, double b) {
    return (a > b) ? a : b;
}

Это называется инстанцирование шаблона. Каждый раз, когда вы используете шаблон с новым типом, компилятор создаёт отдельную копию функции или класса для этого типа.

Важно: Это отличается от того, как работают дженерики в Java или C#. Там компилятор создаёт только одну версию кода, а проверки типов происходят на этапе компиляции. В C++ каждая версия — это отдельный, полностью скомпилированный код. Это даёт максимальную производительность, но может увеличить размер исполняемого файла.

Параметр typename T (можно писать class T — разницы нет) — это параметр типа. Вы можете представить, что T — это «дырка», в которую на этапе компиляции подставляется реальный тип. T может быть любым: int, double, string, ваш собственный класс — всем, что поддерживает операции, которые вы используете внутри шаблона.

Если внутри шаблона вы пишете a > b, то тип T должен поддерживать оператор >. Если вы пишете a + b, то T должен поддерживать оператор +. Если вы вызываете метод a.someMethod(), то у T должен быть этот метод. Компилятор проверит это в момент инстанцирования шаблона и выдаст ошибку, если тип не подходит.

Синтаксис в C++: все формы и варианты

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

1. Шаблон функции

// Базовый синтаксис
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// Можно использовать несколько параметров типа
template <typename T1, typename T2>
void printPair(T1 first, T2 second) {
    std::cout << "(" << first << ", " << second << ")" << std::endl;
}

// Можно указывать тип возвращаемого значения отдельно
template <typename T>
auto getValue(T value) -> decltype(value) {
    return value;
}

2. Шаблон класса

// Объявление шаблонного класса
template <typename T>
class Box {
private:
    T content;  // Поле типа T
public:
    void put(const T& item) {
        content = item;
    }
    
    T get() const {
        return content;
    }
};

// Использование
Box<int> intBox;       // Коробка для целых чисел
Box<std::string> strBox; // Коробка для строк

3. Шаблон с параметрами-значениями

Параметром шаблона может быть не только тип, но и значение (число, указатель, перечисление):

// Шаблон с целочисленным параметром
template <typename T, int Size>
class Array {
private:
    T data[Size];  // Статический массив фиксированного размера
public:
    int getSize() const { return Size; }
    
    T& operator[](int index) {
        return data[index];
    }
};

// Использование
Array<double, 10> tenDoubles;  // Массив из 10 дробных чисел
Array<int, 5> fiveInts;        // Массив из 5 целых чисел

4. Шаблон с параметром-шаблоном

Можно передавать шаблон в качестве параметра другого шаблона. Это продвинутая техника:

// Параметр-шаблон: template<typename> class Container
template <typename T, template<typename> class Container>
class Wrapper {
private:
    Container<T> container;  // Контейнер типа Container<T>
public:
    void add(const T& item) {
        // Предполагаем, что у Container есть метод push_back
        container.push_back(item);
    }
};

// Использование
Wrapper<int, std::vector> vecWrapper;
Wrapper<double, std::list> listWrapper;

5. Специализация шаблона

Иногда нужно, чтобы для конкретного типа шаблон работал по-особенному. Это называется специализация:

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

// Полная специализация для типа bool
template <>
class Printer<bool> {
public:
    void print(const bool& value) {
        std::cout << "Boolean: " << (value ? "true" : "false") << std::endl;
    }
};

// Частичная специализация для указателей
template <typename T>
class Printer<T*> {
public:
    void print(const T* value) {
        if (value) {
            std::cout << "Pointer to: " << *value << std::endl;
        } else {
            std::cout << "Null pointer" << std::endl;
        }
    }
};

6. Псевдонимы шаблонов (C++11)

// Создаём псевдоним для шаблона
template <typename T>
using MyVector = std::vector<T, MyAllocator<T>>;

// Теперь можно писать так:
MyVector<int> vec;  // Вместо std::vector<int, MyAllocator<int>>

7. Шаблонные переменные (C++14)

// Шаблонная переменная
template <typename T>
constexpr T pi = T(3.1415926535897932385);

// Использование
auto piFloat = pi<float>;   // 3.14159f
auto piDouble = pi<double>; // 3.141592653589793

Примеры кода — от простого к сложному

Пример 1: Простейшая шаблонная функция

#include <iostream>
#include <string>

// Шаблон функции для поиска минимального из двух значений
template <typename T>
T min(T a, T b) {
    // Если a меньше b, возвращаем a, иначе b
    return (a < b) ? a : b;
}

int main() {
    // Используем шаблон с разными типами
    int a = 5, b = 10;
    std::cout << "Меньшее из " << a << " и " << b << " = " 
              << min(a, b) << std::endl;  // Выведет: 5
    
    double x = 3.14, y = 2.71;
    std::cout << "Меньшее из " << x << " и " << y << " = " 
              << min(x, y) << std::endl;  // Выведет: 2.71
    
    std::string s1 = "apple", s2 = "banana";
    std::cout << "Меньшее из " << s1 << " и " << s2 << " = " 
              << min(s1, s2) << std::endl;  // Выведет: apple (по алфавиту)
    
    return 0;
}

Объяснение: Функция min объявлена как шаблон с параметром типа T. Внутри она использует оператор <. Компилятор автоматически определяет тип T по аргументам вызова. Для int, double и std::string оператор < определён, поэтому всё работает.

Пример 2: Шаблонный класс «Пара»

#include <iostream>
#include <string>

// Шаблонный класс для хранения пары значений разных типов
template <typename T1, typename T2>
class Pair {
private:
    T1 first;   // Первый элемент
    T2 second;  // Второй элемент
    
public:
    // Конструктор
    Pair(const T1& f, const T2& s) : first(f), second(s) {}
    
    // Методы для доступа к элементам
    T1 getFirst() const { return first; }
    T2 getSecond() const { return second; }
    
    // Метод для вывода пары
    void print() const {
        std::cout << "(" << first << ", " << second << ")" << std::endl;
    }
};

int main() {
    // Создаём пару: строка + целое число
    Pair<std::string, int> student("Иван", 25);
    student.print();  // Выведет: (Иван, 25)
    
    // Создаём пару: целое число + дробное число
    Pair<int, double> coordinates(10, 3.14);
    coordinates.print();  // Выведет: (10, 3.14)
    
    // Создаём пару: строка + строка
    Pair<std::string, std::string> translation("hello", "привет");
    translation.print();  // Выведет: (hello, привет)
    
    return 0;
}

Объяснение: Класс Pair принимает два параметра типа: T1 и T2. Они могут быть разными. В конструкторе мы сохраняем переданные значения. Методы getFirst и getSecond возвращают значения соответствующих типов. Компилятор генерирует отдельный класс для каждой комбинации типов.

Пример 3: Шаблон с параметром-значением

#include <iostream>

// Шаблонный класс для статического массива фиксированного размера
template <typename T, int Size>
class StaticArray {
private:
    T data[Size];  // Массив из Size элементов типа T
    
public:
    // Заполнение массива значением
    void fill(const T& value) {
        for (int i = 0; i < Size; ++i) {
            data[i] = value;
        }
    }
    
    // Доступ по индексу
    T& operator[](int index) {
        // Проверка границ (для отладки)
        if (index < 0 || index >= Size) {
            throw std::out_of_range("Индекс вне диапазона");
        }
        return data[index];
    }
    
    // Получение размера
    int getSize() const { return Size; }
    
    // Вывод всех элементов
    void print() const {
        for (int i = 0; i < Size; ++i) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    // Массив из 5 целых чисел
    StaticArray<int, 5> intArray;
    intArray.fill(42);
    intArray[2] = 100;  // Изменяем третий элемент
    std::cout << "Массив int: ";
    intArray.print();  // Выведет: 42 42 100 42 42
    
    // Массив из 3 дробных чисел
    StaticArray<double, 3> doubleArray;
    doubleArray[0] = 1.1;
    doubleArray[1] = 2.2;
    doubleArray[2] = 3.3;
    std::cout << "Массив double: ";
    doubleArray.print();  // Выведет: 1.1 2.2 3.3
    
    // Размер массива известен на этапе компиляции
    std::cout << "Размер intArray: " << intArray.getSize() << std::endl;  // 5
    std::cout << "Размер doubleArray: " << doubleArray.getSize() << std::endl;  // 3
    
    return 0;
}

Объяснение: Параметр int Size — это не тип, а целое число. Компилятор создаёт отдельный класс для каждой комбинации типа T и значения Size. StaticArray<int, 5> и StaticArray<int, 10> — это разные, несовместимые типы. Размер массива известен на этапе компиляции, что позволяет компилятору оптимизировать код.

Пример 4: Специализация шаблона

#include <iostream>
#include <vector>
#include <list>

// Основной шаблон для вычисления размера контейнера
template <typename Container>
class ContainerSize {
public:
    static size_t getSize(const Container& c) {
        // Для большинства контейнеров используем size()
        return c.size();
    }
};

// Специализация для массивов фиксированного размера
template <typename T, size_t N>
class ContainerSize<T[N]> {
public:
    static size_t getSize(const T (&)[N]) {
        // Для массивов размер известен на этапе компиляции
        return N;
    }
};

// Специализация для std::vector (хотя основная версия тоже работает)
template <typename T>
class ContainerSize<std::vector<T>> {
public:
    static size_t getSize(const std::vector<T>& v) {
        std::cout << "Специализация для vector: ";
        return v.size();
    }
};

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::list<double> lst = {1.1, 2.2, 3.3};
    int arr[] = {10, 20, 30, 40};
    
    std::cout << "Размер vector: " << ContainerSize<std::vector<int>>::getSize(vec) << std::endl;
    std::cout << "Размер list: " << ContainerSize<std::list<double>>::getSize(lst) << std::endl;
    std::cout << "Размер массива: " << ContainerSize<int[4]>::getSize(arr) << std::endl;
    
    return 0;
}

Объяснение: Основной шаблон работает для любых контейнеров, у которых есть метод size(). Специализация для массивов использует тот факт, что размер массива известен на этапе компиляции (параметр N). Специализация для vector добавляет дополнительное сообщение. Компилятор выбирает наиболее подходящую специализацию для каждого типа.

Пример 5: Шаблонная функция с несколькими параметрами

#include <iostream>
#include <string>
#include <type_traits>  // Для std::is_same

// Функция для преобразования значения в строку
// Работает для разных типов
template <typename T>
std::string toString(const T& value) {
    // Используем std::to_string для числовых типов
    if constexpr (std::is_arithmetic_v<T>) {
        return std::to_string(value);
    } else {
        // Для других типов используем оператор <<
        // (требуется, чтобы он был определён)
        return std::string(value);
    }
}

// Специализация для std::string (ничего не делаем)
template <>
std::string toString<std::string>(const std::string& value) {
    return value;
}

// Функция для создания пары из двух значений
template <typename T1, typename T2>
auto makePair(const T1& first, const T2& second) {
    // Возвращаем std::pair (стандартный шаблонный класс)
    return std::make_pair(first, second);
}

int main() {
    // Преобразование разных типов в строку
    std::cout << "int: " << toString(42) << std::endl;
    std::cout << "double: " << toString(3.14159) << std::endl;
    std::cout << "string: " << toString(std::string("Привет")) << std::endl;
    
    // Создание пар
    auto p1 = makePair(10, 20.5);
    auto p2 = makePair(std::string("ключ"), 100);
    
    std::cout << "Пара 1: (" << p1.first << ", " << p1.second << ")" << std::endl;
    std::cout << "Пара 2: (" << p2.first << ", " << p2.second << ")" << std::endl;
    
    return 0;
}

Объяснение: Функция toString использует if constexpr (C++17) для выбора реализации на этапе компиляции. Для арифметических типов вызывается std::to_string, для строк — возвращается копия. Функция makePair автоматически определяет типы аргументов и возвращает std::pair соответствующего типа.

Пример 6: Шаблонный класс-контейнер

#include <iostream>
#include <stdexcept>

// Простой шаблонный класс для динамического массива
template <typename T>
class DynamicArray {
private:
    T* data;        // Указатель на массив
    size_t size;    // Текущий размер
    size_t capacity; // Вместимость
    
    // Вспомогательный метод для увеличения вместимости
    void resize() {
        capacity = (capacity == 0) ? 1 : capacity * 2;
        T* newData = new T[capacity];
        
        // Копируем старые данные
        for (size_t i = 0; i < size; ++i) {
            newData[i] = data[i];
        }
        
        delete[] data;
        data = newData;
    }
    
public:
    // Конструктор
    DynamicArray() : data(nullptr), size(0), capacity(0) {}
    
    // Деструктор
    ~DynamicArray() {
        delete[] data;
    }
    
    // Добавление элемента
    void pushBack(const T& value) {
        if (size >= capacity) {
            resize();
        }
        data[size++] = value;
    }
    
    // Доступ по индексу
    T& operator[](size_t index) {
        if (index >= size) {
            throw std::out_of_range("Индекс вне диапазона");
        }
        return data[index];
    }
    
    // Константный доступ
    const T& operator[](size_t index) const {
        if (index >= size) {
            throw std::out_of_range("Индекс вне диапазона");
        }
        return data[index];
    }
    
    // Получение размера
    size_t getSize() const { return size; }
    
    // Проверка на пустоту
    bool isEmpty() const { return size == 0; }
    
    // Вывод всех элементов
    void print() const {
        for (size_t i = 0; i < size; ++i) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    // Динамический массив целых чисел
    DynamicArray<int> intArray;
    intArray.pushBack(10);
    intArray.pushBack(20);
    intArray.pushBack(30);
    
    std::cout << "Массив int: ";
    intArray.print();  // Выведет: 10 20 30
    
    // Динамический массив строк
    DynamicArray<std::string> strArray;
    strArray.pushBack("Hello");
    strArray.pushBack("World");
    
    std::cout << "Массив строк: ";
    strArray.print();  // Выведет: Hello World
    
    // Доступ по индексу
    std::cout << "Элемент [1]: " << intArray[1] << std::endl;  // 20
    
    return 0;
}

Объяснение: Класс DynamicArray — это упрощённая версия std::vector. Он работает с любым типом T. Внутри он хранит указатель на динамический массив. Метод pushBack добавляет элемент, при необходимости увеличивая вместимость. Оператор [] позволяет обращаться к элементам. Деструктор освобождает память.

Пример 7: Шаблон с вариативными параметрами (C++11)

#include <iostream>
#include <sstream>

// Базовый случай: один аргумент
template <typename T>
std::string joinToString(const T& value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}

// Рекурсивный шаблон: несколько аргументов
template <typename T, typename... Args>
std::string joinToString(const T& first, const Args&... rest) {
    std::ostringstream oss;
    oss << first;  // Преобразуем первый аргумент
    
    // Если есть ещё аргументы, добавляем разделитель и рекурсивно обрабатываем остальные
    if constexpr (sizeof...(rest) > 0) {
        oss << ", " << joinToString(rest...);
    }
    
    return oss.str();
}

// Функция для вычисления суммы произвольного количества аргументов
template <typename T>
T sum(const T& value) {
    return value;
}

template <typename T, typename... Args>
T sum(const T& first, const Args&... rest) {
    return first + sum(rest...);
}

int main() {
    // Соединение строк с разделителем
    std::string result = joinToString(1, 2.5, "три", 4);
    std::cout << "Результат joinToString: " << result << std::endl;
    // Выведет: 1, 2.5, три, 4
    
    // Сумма чисел
    int total = sum(1, 2, 3, 4, 5);
    std::cout << "Сумма: " << total << std::endl;  // 15
    
    double totalDouble = sum(1.1, 2.2, 3.3);
    std::cout << "Сумма double: " << totalDouble << std::endl;  // 6.6
    
    return 0;
}

Объяснение: typename... Args — это пакет параметров (parameter pack). Функция может принимать любое количество аргументов. Рекурсивный шаблон обрабатывает первый аргумент, а затем вызывает себя для остальных. Базовый случай (один аргумент) останавливает рекурсию. sizeof...(rest) возвращает количество оставшихся аргументов на этапе компиляции.

Сравнение с Python: чем похоже и чем отличается

Характеристика	C++ (шаблоны)	Python (дженерики)
Время проверки типов	На этапе компиляции	На этапе выполнения (или с помощью mypy — статический анализ)
Количество генерируемого кода	Отдельная версия для каждого типа (может быть много)	Одна версия для всех типов (используется утиная типизация)
Производительность	Максимальная (нет накладных расходов на выполнение)	Меньше (проверки типов во время выполнения)
Синтаксис	`template <typename T>` и `Box<int>`	`from typing import TypeVar, Generic` и `Box[int]`
Ограничения на типы	Любой тип, поддерживающий нужные операции (проверяется при компиляции)	Любой тип (проверяется при выполнении, может быть ошибка)
Специализация	Поддерживается (полная и частичная)	Нет прямой поддержки (можно через isinstance)
Параметры-значения	Поддерживаются (например, `template <int N>`)	Не поддерживаются
Вариативные шаблоны	Поддерживаются (C++11)	Поддерживаются через `*args` (но без проверки типов)
Использование в стандартной библиотеке	Почти всё: vector, map, algorithm, smart pointers	list, dict, tuple (но они не параметризованы типами в рантайме)

Пример на

← Предыдущая Лямбда-функции и функциональный стиль в C++: подро Вперёд → Итераторы и генераторы в C++: подробное руководств