Шаблоны C++: обобщённые функции и классы простыми словами

Напишите один раз — используйте для любого типа

На предыдущей странице вы отсортировали vector<int> с помощью std::sort. Но std::sort сортирует и vector<string>, и vector<double>, и массив ваших собственных структур — при этом никто не пишет отдельный sort для каждого. Это не магия и не перегрузка. Это шаблон: единственный фрагмент кода, который компилятор переиспользует для любого типа, который вы ему передаёте.

Без шаблонов вы были бы вынуждены копировать одну и ту же логику для каждого типа. Вот одна и та же функция maximum, написанная трижды, — ровно то дублирование, ради устранения которого и существуют шаблоны:

int    maximum(int a, int b)       { return a > b ? a : b; }
double maximum(double a, double b) { return a > b ? a : b; }
string maximum(string a, string b) { return a > b ? a : b; }

Тела идентичны. Различаются только типы. Шаблон позволяет сказать «это работает для любого типа T» и написать это один раз.

Шаблоны функций

Вы превращаете функцию в шаблон, добавляя перед ней template <typename T> и используя T везде, где обычно стоял бы конкретный тип.

#include <iostream>
#include <string>
using namespace std;

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

int main() {
    cout << maximum(3, 7) << "\n";          // 7   (T = int)
    cout << maximum(2.5, 1.1) << "\n";      // 2.5 (T = double)
    cout << maximum(string("apple"),
                    string("banana")) << "\n"; // banana (T = string)
    return 0;
}

Обратите внимание: вы нигде не писали maximum<int> или maximum<double>. Компилятор смотрит на аргументы и определяет, чем должно быть T, — это вывод аргументов шаблона. Каждый отдельный тип, с которым вы её вызываете, заставляет компилятор инстанцировать (сгенерировать) отдельную конкретную функцию за кулисами.

Вы можете указать тип явно, когда вывод не справляется, используя угловые скобки:

#include <iostream>
using namespace std;

template <typename T>
T zero() {            // выводить нечего - аргументов нет
    return T{};
}

int main() {
    cout << zero<int>() << "\n";     // 0
    cout << zero<double>() << "\n";  // 0
    return 0;
}

В выводе типов кроется распространённая ловушка. Поскольку T должно быть единственным типом, смешивание типов аргументов ломает его:

maximum(3, 7.5);   // ОШИБКА: T - это int или double? Компилятор отказывается гадать.

Это можно исправить, указав тип явно — maximum<double>(3, 7.5) — или дав каждому параметру свой собственный параметр типа, что мы и сделаем дальше.

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

Шаблон не ограничен одним типом. Перечислите столько, сколько нужно, через запятую. Вот как написать функцию, параметры которой могут быть разных типов:

#include <iostream>
#include <string>
using namespace std;

template <typename A, typename B>
void printPair(A first, B second) {
    cout << first << " -> " << second << "\n";
}

int main() {
    printPair(1, "one");        // A = int, B = const char*
    printPair(3.14, true);      // A = double, B = bool
    printPair("pi", 3.14159);   // A = const char*, B = double
    return 0;
}

Когда тип возвращаемого значения зависит от параметров, позвольте компилятору вычислить его с помощью auto (C++14 и новее), который естественно сочетается с шаблонами:

#include <iostream>
using namespace std;

template <typename A, typename B>
auto add(A a, B b) {
    return a + b;   // тип возврата выводится из a + b
}

int main() {
    cout << add(2, 3) << "\n";     // 5    (int + int)
    cout << add(2, 3.5) << "\n";   // 5.5  (int + double -> double)
    return 0;
}

Шаблоны классов

Шаблоны нужны не только для функций — шаблонами могут быть целые классы. Именно так работают стандартные контейнеры: vector<int>, словарь «ключ-значение» map<string, int> и pair<A, B> — все они шаблоны классов. Вы пишете структуру данных один раз, и она хранит тот тип, которым вы её параметризуете.

Вот крошечный обобщённый Box, хранящий одно значение любого типа:

#include <iostream>
#include <string>
using namespace std;

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T get() const { return value; }
    void set(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<string> wordBox("hello");

    cout << intBox.get() << "\n";   // 42
    cout << wordBox.get() << "\n";  // hello

    intBox.set(100);
    cout << intBox.get() << "\n";   // 100
    return 0;
}

Ключевое отличие от шаблонов функций: с шаблоном класса вам обычно приходится указывать тип в угловых скобках — Box<int> — потому что в старых стандартах нет аргументов конструктора, из которых его можно было бы вывести. (В C++17 добавили вывод аргументов шаблона класса, так что Box b(42); тоже работает, но указывать явно всегда безопасно и читается ясно.)

Ошибки будут огромными — вот почему

Это та часть, на которой все спотыкаются, поэтому скажем прямо. Шаблон полностью проверяется только тогда, когда он инстанцируется с реальным типом. Можно написать шаблон, который использует <, и сам по себе он прекрасно компилируется — ошибка появляется лишь в тот момент, когда вы инстанцируете его с типом, у которого нет <.

template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;   // требует, чтобы T поддерживал >
}

struct Point { int x, y; };

// maximum(Point{1,2}, Point{3,4});
// ОШИБКА: нет operator > для Point. Сообщение называет Point И
// цитирует всю эту функцию, часто растягиваясь на многие строки.

Поскольку компилятор подставляет полный тип в шаблон и сообщает об ошибках изнутри сгенерированного кода, одна-единственная ошибка может породить стену вывода, упоминающую внутренности библиотеки. Два совета на выживание:

• Читайте первую ошибку, а не последнюю. Последующие ошибки обычно — следствие первой.
• Ищите в сообщении имя вашего собственного типа (здесь Point). Оно подскажет, какое инстанцирование пошло не так.

Настоящее решение — убедиться, что ваш тип поддерживает всё, что нужно шаблону: для maximum это значит дать Point перегрузку оператора operator>, что относится к более поздней странице. Концепты современного C++20 могут вытащить эти ошибки раньше и сделать их читаемыми, но лежащая в основе модель подстановки остаётся той же.

Далее: Классы

Вы только что построили шаблон класса Box — класс с приватными данными, конструктором и методами — сосредоточившись на самих шаблонах. Следующая страница замедляется и учит классам как следует: как объединять данные с функциями, которые с ними работают, что на самом деле контролируют public и private и как методы обращаются к собственному состоянию объекта. Шаблоны и классы в реальном C++ постоянно сочетаются, так что прочное владение классами делает написание обобщённого кода куда проще.