Язык программирования C++. Пятое издание - Стенли Липпман

Параметр значения шаблона — это константное значение в определении шаблона. Параметр значения применим там, где требуются константные выражения, например, при определении размера массива.

Аргументы шаблона, используемые для параметров значения, должны быть константными выражениями.

Шаблоны функции со спецификаторами inline и constexpr

Шаблон функции может быть объявлен как inline (встраиваемый) или constexpr, как и обычная функция. Спецификаторы inline и constexpr располагаются после списка параметров шаблона, но перед типом возвращаемого значения.

// ok: спецификатор inline следует за списком параметров шаблона

template <typename Т> inline Т min(const Т&, const Т&);

// ошибка: неправильное размещение спецификатора inline

inline template <typename T> T min(const T&, const T&);

Создание кода, независимого от типа

Продемонстрируем два наиболее важных принципа создания обобщенного кода на примере функции compare().

• Параметры функций в шаблоне должны быть ссылками на константу.

• При проверке в теле шаблона следует использовать только оператор сравнения <.

Объявление параметров функций ссылками на константы гарантирует возможность применения функции к типам, которые не допускают копирования. Большинство типов, включая встроенные типы, но исключая указатели unique_ptr и типы ввода-вывода, а также все использованные ранее библиотечные типы допускают копирование. Но вполне могут встретиться и другие типы, которые не допускают копирования. Сделав параметры ссылками на константы, можно гарантировать применимость таких типов в функции compare(). Кроме того, если функция compare() будет применена для больших объектов, такая конструкция позволит избежать копирования и сэкономит время при выполнении.

Некоторые читатели могут подумать, что для сравнения было бы целесообразней использовать оба оператора < и >.

// ожидаемое сравнение

if (v1 < v2) return -1;

if (v1 > v2) return 1;

return 0;

Однако написание кода, использующего только оператор <, снизит требования к типам, которые применимы в функции compare(). Эти типы должны поддерживать оператор <, но не обязаны поддерживать оператор >.

Фактически, если действительно следует обеспечить независимость от типа и переносимость кода, лучше определить свою функцию, используя тип less (см. раздел 14.8.2):

// версия функции compare(), корректно работающая даже с

// указателями; см. p. 14.8.2

template <typename Т> int compare(const T &v1, const T &v2) {

 if (less<T>()(v1, v2)) return -1;

 if (less<T>()(v2, v1)) return 1;

 return 0;

}

Проблема первоначальной версии в том, что если пользователь вызовет ее с двумя указателями, не указывающими на тот же массив, то результат выполнения кода будет непредсказуем.

При написании кода шаблонов следует постараться минимизировать количество требований, накладываемых на типы аргументов.

Компиляция шаблона

Когда компилятор встречает определение шаблона, он не создает код. Код создается только при создании специфического экземпляра шаблона. Тот факт, что код создается только при использовании шаблона (а не при его определении), влияет как на организацию исходного кода, так и на способы обнаружения ошибок.

Обычно, когда происходит вызов функции, компилятору достаточно объявления функции. Точно так же при использовании объекта класса должно быть доступно определение класса, но определения функций-членов не обязательны. В результате определения классов и объявления функций имеет смысл размещать в файлах заголовка, а определения обычных функций и функций-членов — в файлах исходного кода.

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

Определения шаблонов функций и функций-членов шаблонов классов обычно помещаются в файлы заголовка.

Ключевая концепция. Шаблоны и заголовки

Шаблоны содержат два вида имен:

• не зависящие от параметров шаблона;

• зависящие от параметров шаблона.

Именно разработчик шаблона гарантирует, что все имена, не зависящие от параметров шаблона, будут видимы на момент использования шаблона. Кроме того, разработчик шаблона должен гарантировать видимость определения шаблона, включая определения членов шаблона класса, на момент создания экземпляра шаблона.

Пользователь шаблона должен обеспечить видимость объявлений всех функций, типов и связанных с ними операторов, используемых при создании экземпляра шаблона.

Выполнение этих требований невозможно без хорошо организованной структуры программы, в которой заголовки используются соответствующим образом. Автор шаблона должен предоставить заголовок, который содержит объявления всех имен, используемых в шаблоне класса или в определениях его членов. Прежде чем создать экземпляр шаблона для определенного типа или использовать член класса, созданного по этому шаблону, пользователь должен подключить заголовок для типа шаблона и заголовок, в котором определен используемый тип.

Ошибки компиляции проявляются, главным образом, во время создания экземпляра

Тот факт, что код не создается до создания экземпляра шаблона, влияет на то, когда проявляются ошибки компиляции в коде шаблона. В процессе создания шаблона есть три этапа, во время которых компилятор может сообщить об ошибке.

Первый — когда компилируется само определение шаблона. На этом этапе компилятор, как правило, не может найти большую часть ошибок. Здесь обнаруживаются в основном синтаксические ошибки, такие как пропущенная точка с запятой или неправильно написанное имя переменной, но не более.

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

Третий этап обнаружения ошибок — момент создания экземпляра. Только теперь обнаруживаются ошибки, связанные с типами. В зависимости от того, как компилятор осуществляет создание экземпляра, он может сообщить об этих ошибках во время редактирования.

При написании шаблона код не может быть открыто специфическим для типа, но можно сделать некоторые предположения об используемых типах. Например, код первоначальной функции compare() подразумевал, что тип аргумента имеет оператор <.

if (v1 < v2) return -1; // для объектов типа Т требуется оператор <

if (v2 < v1) return 1;  // для объектов типа Т требуется оператор <

return 0;               // возвращает int; не зависит от Т

Когда компилятор обрабатывает тело этого шаблона, он не может проверить корректность условий в операторах if. Если переданные функции compare() аргументы имеют оператор <, то код сработает прекрасно, но не в противном случае. Например:

Sales_data data1, data2;

cout << compare(data1, data2) << endl; // ошибка: у Sales_data нет

                                       // оператора <

Этот вызов создает экземпляр функции compare() с параметром Т, замененным классом Sales_data. Если условия попытаются использовать оператор < для объектов класса Sales_data, то окажется, что такого оператора нет. В результате получится экземпляр функции, которая не будет откомпилирована. Такие ошибки, как эта, не могут быть обнаружены, пока компилятор не создаст экземпляр определения функции compare() для типа Sales_data.

Вызывающая сторона должна гарантировать, что переданные шаблону аргументы поддерживают все используемые им операторы, а также то, что эти операторы будут вести себя правильно в том контексте, в котором шаблон использует их.

Упражнения раздела 16.1.1

Упражнение 16.1. Определите создание экземпляра.

Упражнение 16.2. Напишите и проверьте собственные версии функций compare().