Что такое template
Перейти к содержимому

Что такое template

  • автор:

Перевод «template» на русский

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

But i have worked for this template.
И, тем не менее, мы боролись за этот храм.
Yes, you can edit the template as you like.
И наконец, можете украсить ваш храм так, как вам нравится.
And this really became the template for moving forward.
И это в действительности стало шаблоном, от которого мы двинулись вперед.
No template parsing overhead, only compiles once.
Никакой лишней обработки шаблонов, они компилируются только один раз.
Chart windows acquire all properties and elements of a template.
Окно графика приобретает все свойства и элементы, которые содержатся в шаблоне.
You can use this template for both business and personal correspondence.
Этот шаблон можно применять как для деловой, так и для личной переписки.
This template creates a site designed for records management.
На основе этого шаблона создается сайт, предназначенный для управления записями.
Think about utilizing a one-page template for your homepage and moving your conversion funnel there.

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

Write a template with sections for all the key information.
Создайте шаблон, в котором будут предусмотрены секции для всей ключевой информации.
You cannot change the template you have chosen.
Вы не можете изменить шаблон, который вы изначально выбрали.
Please remove this template after editing.
Пожалуйста, не удаляйте этот шаблон при редактировании.
Use this template to ask for help.
Люди идут в этот храм, чтобы попросить помощи.
Spreadsheet software includes basic lessons for template set up in their help files.

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

You can make a template like that yourself.
Поэтому, вы можете найти для себя именно такой храм.
Joomla comes with preinstalled templates and so called template styles.
Joomla поставляется с предустановленными шаблонами и, так называемыми, стилями шаблонов.
Jacob is the responsive template we picked for our future fan website.
Jacob — это адаптивный шаблон, который мы выбрали для нашего будущего фан сайта.
Yes, even a totally different template.
То есть, имелся в виду совсем другой храм.
You are already halfway now that you have your template.
Вы уже на полпути теперь, когда у вас есть свой шаблон.
Возможно неприемлемое содержание

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

Шаблоны и шаблонные функции в C++. Введение

Давайте рассмотрим простой пример. Допустим, у нас есть функция, которая меняет местами значения двух переменных типа int:

#include void my_swap ( int & first , int & second ) < int temp ( first ) ; first = second ; second = temp ; >int main ()

Теперь, допустим, у нас в функции main так же есть две переменные типа double, значения которых тоже нужно обменять. Функция для обмена значений двух переменных типа int нам не подойдет. Напишем функцию для double:

void my_swap ( double & first , double & second )

И теперь перепишем main:

int main ()

Как видите, у нас алгоритм абсолютно одинаковый, отличаются лишь типы параметров и тип переменной temp. А теперь представьте, что нам еще нужны функции для short, long double, char, string и еще множества других типов. Конечно, можно просто скопировать первую функцию, и исправить типы на нужные, тогда получим новую функцию с необходимыми типами. А если функция будет не такая простая? А вдруг потом еще обнаружится, что в первой функции была ошибка? Избежать всего этого можно, например, «шаманством» с препроцессором, но это нам ни к чему, нам помогут шаблоны.

Для начала, заглянем в википедию и посмотрим, что же такое шаблоны:

Шабло́ны (англ. template) — средство языка C++, предназначенное для кодирования обобщённых алгоритмов, без привязки к некоторым параметрам (например, типам данных, размерам буферов, значениям по умолчанию).
https://ru.wikipedia.org/wiki/Шаблоны_C++

Итак, описание шаблона начинается с ключевого слова template за которым в угловых скобках («») следует список параметров шаблона. Далее, собственно идет объявление шаблонной сущности (например функция или класс), т. е. имеет вид:

Теперь давайте напишем шаблонную функцию my_swap. Исходя из упомянутой выше структуры объявления шаблона следует, что наша функция будет выглядеть так:

template < typename T >void my_swap ( T & first , T & second )

typename в угловых скобках означает, что параметром шаблона будет тип данных. T — имя параметра шаблона. Вместо typename здесь можно использовать слово class: template В данном контексте ключевые слова typename и class эквивалентны (лично мне больше нравится typename, а кому-то class). Далее, в тексте шаблона везде, где мы используем тип T, вместо T будет проставляться необходимый нам тип.

void my_swap ( T & first , T & second ) //T - тип, указанный в параметре шаблона < T temp(first) ; //временная переменная должна быть того же типа, что и параметры first = second ; second = temp ; >

теперь давайте напишем функцию main:

int main () < int a = 5 ; int b = 10 ; std::cout ( a , b ) ; std::cout ( c , d ) ; std::cout

Как видите, после имени функции в угловых скобках мы указываем тип, который нам необходим, он то и будет типом T. Шаблон — это лишь макет, по которому компилятор самостоятельно будет генерировать код. При виде такой конструкции: my_swap компилятор сам создаст функцию my_swap с необходимым типом. Это называется инстанцирование шаблона. То есть при виде my_swap компилятор создаст функцию my_swap в которой T поменяет на int, а при виде my_swap будет создана функция с типом double. Если где-то дальше компилятор опять встретит my_swap , то он ничего генерировать не будет, т.к. код данной функции уже есть(шаблон с данным параметром уже инстанцирован).

Таким образом, если мы инстанцируем этот шаблон три раза с разными типами, то компилятор создаст три разные функции

Вывод типа шаблона исходя из параметров функции

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

рассмотрим вызов функции без указания типа:

int a = 5 ; int b = 10 ; my_swap ( a , b ) ; 

Наша шаблонная функция принимает параметры типа T&, основываясь на шаблоне, компилятор видит, что Вы передаете в функцию аргументы типа int, поэтому может самостоятельно определить, что в данном месте имеется ввиду функция my_swap с типом int. Это deducing template arguments. Теперь давайте напишем пример посложнее. Например, программу сортировки массива(будем использовать сортировку «пузырьком»). Естественно, что алгоритм сортировки один и тот же, а вот типы элементов в массиве будут отличаться. Для обменивания значений будем использовать нашу шаблонную функцию my_swap. Приступим:

#include template < typename T >void my_swap ( T & first , T & second ) //T - тип, указанный в параметре шаблона < T temp(first) ; //временная переменная должна быть того же типа, что и параметры first = second ; second = temp ; >//Функция будет принимать указатель на данные //и кол-во элементов массива данных //Сам алгоритм сортировки можете посмотреть в Интернете. //Никаких оптимизаций и проверок аргументов применять не будем, нам нужна просто демонстрация. template < class ElementType >//Использовал class, но можно и typename - без разницы void bubbleSort(ElementType * arr, size_t arrSize) < for(size_t i = 0; i < arrSize - 1; ++i) for(size_t j = 0; j < arrSize - 1; ++j) if (arr[j + 1] < arr[j]) my_swap ( arr[j] , arr[j+1] ) ; >template < typename ElementType >void out_array ( const ElementType * arr , size_t arrSize ) < for ( size_t i = 0 ; i < arrSize ; ++i ) std::cout int main () < const size_t n = 5 ; int arr1 [ n ] = < 10 , 5 , 7 , 3 , 4 >; double arr2 [ n ] = < 7.62 , 5.56 , 38.0 , 56.0 , 9.0 >; std::cout 

Source arrays: 10 5 7 3 4 7.62 5.56 38 56 9 Sorted arrays: 3 4 5 7 10 5.56 7.62 9 38 56

Как видите, компилятор сам генерирует out_array для необходимого типа. Так же он сам генерирует функцию bubbleSort. А в bubbleSort у нас применяется шаблонная функция my_swap, компилятор сгенерирует и её код автоматически. Удобно, не правда ли?

Введение в шаблонные классы

Шаблонными могут быть не только функции. Рассмотрим шаблонные классы. Начнем с простого примера. Мы добавим в наш предыдущий код функцию, которая будет искать максимум и минимум в массиве. При создании функции «упираемся» в проблему — как вернуть два указателя? Можно передать их в функцию в качестве параметров, а можно вернуть объект, который будет содержать в себе два указателя. Первый вариант при большом кол-ве возвращаемых значений приведет к заваливанию функции параметрами, поэтому я предлагаю сделать структуру:

struct my_pointer_pair < тип * first ; тип * second ; >; 

А какого же типа будут указатели? Можно сделать их void*, но тогда придется постоянно кастовать их к нужному типу, и код станет похож на «Доширак». А что, если сделать эту структуру шаблонной? Попробуем:

template < typename T, typename U >struct my_pointer_pair < T * first ; U * second ; >; 

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

int main () < my_pointer_pairobj = < new int(10) , new double(67.98) >;//Создаем объект типа my_pointer_pair std::cout

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

Теперь давайте напишем код шаблонной функции для поиска максимума и минимума:

//Шаблон наш будет с одним параметром - тип элементов массива (T) //Возвращаемое значение - объект типа my_pointer_pair < T , T >//т.е. first и second в my_pointer_pair будут иметь тип T*. template < typename T >my_pointer_pair < T , T >my_minmax_elements ( T * arr , size_t arrSize ) < my_pointer_pair< T , T >result = < 0 , 0 >; if ( arr == 0 || arrSize < 1 ) return result ; result.first = arr ; result.second = arr ; for ( size_t i = 1 ; i < arrSize ; ++i ) < if ( arr[i] < *result.first ) result.first = arr+i ; if ( arr[i] >*result.second ) result.second = arr+i ; > return result ; > 

Теперь мы можем вызывать данную функцию:

my_pointer_pair < int , int >mm = my_minmax_elements ( arr1 , n ) ; 

Для классов мы должны явно указывать параметры шаблона. В стандарте C++11, устаревшее ключевое слово auto поменяло свое значение и теперь служит для автоматического вывода типа в зависимости от типа инициализатора, поэтому мы можем написать так:

auto mm = my_minmax_elements ( arr1 , n ) ; 

Предлагаю написать еще одну функцию, которая будет выводить объект my_pointer_pair в стандартный поток вывода:

template < typename T1 , typename T2 >void out_pair ( const my_pointer_pair < T1 , T2 >& mp ) < if ( mp.first == 0 || mp.second == 0 ) std::cout int main () < const size_t n = 5 ; int arr1 [ n ] = < 10 , 5 , 7 , 3 , 4 >; double arr2 [ n ] = < 7.62 , 5.56 , 38.0 , 56.0 , 9.0 >; std::cout 

Arrays: 10 5 7 3 4 7.62 5.56 38 56 9 min = 3 max = 10 min = 5.56 max = 56

Шаблоны и STL

В комплекте с компилятором Вам предоставляется стандартная библиотека шаблонов (Standart Template Library). Она содержит множество шаблонных функций и классов. Например, класс двусвязного списка(list), класс «пара» (pair), функция обмена двух переменных(swap), функции сортировок, динамически расширяемый массив(vector) и т.д. Всё это — шаблоны и Вы можете их использовать. Для небольшого примера возьмем std::vector:

#include #include #include int main () < std::vector arr; arr.push_back ( 5 ) ; //Добавляем элемент в конец arr.push_back ( 7 ) ; arr.push_back ( 3 ) ; arr.push_back ( 8 ) ; std::cout 

Заметьте, когда писали std::vector, авторы понятия не имели, элементы какого типа Вы будете хранить.

Шаблоны это слишком большой и мощный инструмент и описать всё в одной статье не представляется возможным. Это было лишь небольшое введение в мир шаблонов. Углубляясь в шаблоны, Вы поразитесь тому, какой мощный это инструмент и какие возможности он предоставляет.

P.S. высказывайте мнение о статье, критику, дополнения/исправления и интересующие вопросы в комментариях.

P.P.S. Просьба вопросы «консоль закрывается, что делать?», «русский язык не показывает. Что делать?», «как работает сортировка?», «что такое size_t», «что такое std::» и им подобные задавать либо в гугл, либо искать на данном сайте в других статьях. Не нужно захламлять комментарии этой чепухой. Если Вы этого не знаете, то может лучше сначала подтянуть свои знания?

Просто о шаблонах C++

Статья написана с целью максимально просто, на живых примерах рассказать о шаблонах C++.

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

Статья пытается ответить на все эти и многие другие вопросы.

Вступление

Для того чтобы статья читалась с большей пользой, по желанию можно ознакомиться с несколькими ремарками:

  1. Статья написана с прицелом на начинающих разработчиков. Тем не менее, от читателя ожидается минимальная подготовка. Для эффективного изучения шаблонов стоит понимать синтаксис C++, знать, как работают его управляющие конструкции , понимать, что такое функции и их перегрузки, а также иметь общее представление о классах.
  2. Для лучшего восприятия стоит читать статью последовательно, от начала до конца. Разделы располагаются в порядке нарастания сложности. Последующие разделы развивают примеры предыдущих. При этом код используется наравне с текстом - объяснения даются прямо в комментариях.
    Примечание: После публикации оказалось, что развёрнутые комментарии в коде неудобно читать с мобильных устройств. Постараюсь учесть это замечание в следующих статьях.
  3. Стоит компилировать примеры. В идеале, экспериментировать: пробовать менять и улучшать код. Как любая другая тема в программировании, шаблоны лучше всего познаются практикой. Если лень разбираться с настройкой среды разработки , можно использовать какой-нибудь онлайн-компилятор. Например, для анализа ассемблерного кода, получаемого после компиляции, в статье использовался онлайн-компилятор godbolt.org (с отключением оптимизаций опцией "-O0").
  4. Вопреки традиции учебных материалов, примеры кода не содержат распечатки переменных в поток вывода (без "printf" / "std::cout"). Это было сделано намеренно, чтобы избежать лишнего шума в коде. Если будете компилировать код примеров в IDE, можете просматривать значения переменных в дебаггере. Если же удобнее использовать поток вывода - как вариант, можно использовать следующий макрос: Макрос PrintExpression

// В начале файле где объявляется макрос не забудьте добавить // инклуд: "#include " // Собственно, сам макрос. Распечатывает в "std::cout" выражение // в виде строки (для упрощение чтения выражение обрамляется // фигурными скобками) и значение вычисленного выражения. #define PrintExpression(Expression)\ std::cout : " : 1 // 2. Распечатка выражения int arrayValue[]< 1, 2, 3, 4 >; PrintExpression(arrayValue[1] + arrayValue[2]) // Распечатает следующее: : 5

Оглавление

  1. Шаблоны функций
  2. Выведение типов шаблонных аргументов
  3. Шаблоны классов
  4. Специализации
  5. Валидация шаблонных аргументов
  6. Больше шаблонных аргументов
  7. Шаблонные аргументы-константы
  8. Передача шаблонных аргументов
  9. Частичные специализации шаблонов

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

Концепция шаблонов возникла из принципа программирования Don't repeat yourself. Можно проследить логику, по которой авторы C++ ввели шаблоны в язык.

В процедурном программировании повторяющиеся фрагменты кода выносятся в функции. Код, вычисляющий большее из трёх значений…

int main() < const int a = 3, b = 2, c = 1; const int abMax = (a >= b) ? a : b; const int max = (abMax >= c) ? abMax : c; return 0; > 

…переписывают, убирая логику в функцию:

int max(int a, int b) < return (a >= b ? a : b); > //. int main()

Использование функций даёт несколько преимуществ:

  1. Если надо поменять повторяющуюся логику - достаточно сделать это в функции, не надо менять все копии одинакового кода в программе. Если бы в примере выше вариант без функции содержал системную ошибку в тернарных вызовах, с путаницей порядка операндов: "(a >= b) ? b : a" и "(max_ab >= c) ? c : max_ab" - ошибку пришлось бы искать и править во всех местах использования. Вариант с функцией же требует одной правки - в реализации функции.
  2. При грамотном именовании в коде с функциями логика кода становится прозрачнее. В примере без функции внимательного прочтения требует каждая конструкция вида "(. >= . ) ? . : . " , надо узнавать повторяющуюся логику выбора большего значения из двух каждый раз заново. Функция же во втором варианте именует повторяющуюся логику, за счёт чего общий смысл программы понятнее.

Процедурное программирование делает код чище. Однако, что если логику получения максимального элемента надо поддерживать для всех числовых типов: для всех размеров (1, 2, 4, 8 байт), как знаковых, так и беззнаковых (signed / unsigned), для чисел с плавающей точкой ("float", "double")?

Можно воспользоваться перегрузкой функций:

char max(char a, char b) < return (a >= b ? a : b); > unsigned char max(unsigned char a, unsigned char b) < return (a >= b ? a : b); > short int max(short int a, short int b) < return (a >= b ? a : b); > unsigned short int max(unsigned short int a, unsigned short int b) < return (a >= b ? a : b); > int max(int a, int b) < return (a >= b ? a : b); > unsigned int max(unsigned int a, unsigned int b) < return (a >= b ? a : b); > // . и т.д. для всех числовых типов, включая "float" и "double". int main() < const int a = 3, b = 2, c = 1; const int abMaxInt = max(a, b); const int maxInt = max(abMax, c); // . зато теперь можно получить максимальный "char" const char aChar = 'c', bChar = 'b', cChar = 'a'; const char abMaxChar = max(aChar, bChar); const char maxChar = max(abMaxChar, cChar); return 0; >

Выглядит громоздко. Что печальнее, теряются преимущества процедурного программирования. Логика, совпадающая с точностью до типа, копируется в каждой из перегрузок заново.

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

// Ниже описывается шаблон функции max, имеющей один шаблонный аргумент // с именем "Type". Имя может быть любым другим, правила формирования те же что // для именования переменных и типов. // Вместо ключевого слова "typename" для обозначения шаблонного аргумента-типа // может использоваться ключевое слово "class". Не считая некоторых нюансов // (выходящих за рамки данной статьи) эти ключевые слова абсолютно синонимичны. template Type max(Type a, Type b) < return (a >= b ? a : b); > int main() < // Использование шаблона "max(Type, Type)" с подстановкой "int" const int a = 3, b = 2, c = 1; const int abMax = max(a, b); const int max = max(abMax, c); // Использование того же шаблона max(Type, Type) с подстановкой "char" const char aChar = 3, bChar = 2, cChar = 1; const char abMaxChar = max(aChar, bChar); const char maxChar = max(abMaxChar, cChar); return 0; > 

Перегрузки функций с повторяющийся логикой заменились на одну "функцию" с новой конструкцией - template . Слово "функция" взято тут в кавычки намеренно. Это не совсем функция. Данная запись означает для компилятора следующее: "После конструкции template описан шаблон функции, по которому подстановкой типа вместо шаблонного аргумента Type порождаются конкретные функции".

Не стоит путать при этом аргументы функции (в примере - это "Type a" и "Type b") и аргументы шаблона (в примере - это "typename Type"). Первые задают значения, которые принимает функция при вызове. Вторые же задают параметры, подстановкой в которые значений по месту использования порождаются конкретные функции из шаблонов.

Использование шаблона выглядит так: "max(a, b)". В треугольных скобках передаются значения шаблонных аргументов. В данном случае, в качестве значения шаблонного аргумента "Type" передаётся значение - тип "int". После подстановки компилятор создаст "под капотом" конкретную функцию из обобщённого кода. То, что вызывается по записи "max()", для компилятора выглядит так:

int max(int a, int b) < return (a >= b ? a : b); >

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

Встретив же следующую запись - "max(aChar, bChar)" - компилятор породит для себя новую функцию - но по тому же шаблону:

// Функция max() для компилятора выглядит так char max(char a, char b) < return (a >= b ? a : b); >

Несмотря на родство по шаблону, функции "max()" и "max()" - совершенно самостоятельны, каждая из них будет превращаться при компиляции в свой ассемблерный код.

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

Зафиксируем также терминологию более высокого уровня.

Парадигму программирования, в которой единожды описанный алгоритм может применяться для разных типов, называют обобщённым программированием . Помимо языка C++, который качественно реализует эту парадигму с помощью шаблонов, обобщённое программирование в той или иной мере поддерживают многие популярные языки: C#, Java, TypeScript (каждый по-своему реализует парадигму посредством обобщений ), Python (на уровне аннотаций типов) .

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

2. Выведение типов шаблонных аргументов

В примере с шаблоном функции "template max(Type, Type)" использовалась явная передача типов в шаблон. Однако во многих случаях компилятор может автоматически вывести тип шаблонного аргумента.

Вызов шаблонной функции из примера.

// const int a = 3, b = 2; const int abMax = max(a, b);

. можно записать, опустив :

// const int a = 3, b = 2; const int abMax = max(a, b);

Такая запись корректна с точки зрения языка. Компилятор проанализирует типы переменных "a" и "b" и выполнит выведение типа для передачи в качестве значения шаблонного аргумента "Type".

Тип переменной "a" - "int", тип переменной "b" – тоже "int". Они передаются в шаблон функции "template Type max(Type, Type)", в котором ожидается, что оба аргумента будут иметь одинаковый тип "Type". Так как типы "a" и "b" совпадают, и нет других правил ограничивающих данный шаблонный аргумент "Type", компилятор делает вывод, что записью "max(a, b)" ожидают применения шаблонной функции "max(a, b)".

Стоит отметить, что, например, следующий код.

const int a = 1; const char bChar = 'b'; const int abMax = max(a, bChar);

. не скомпилируется с ошибкой вроде: "deduced conflicting types for parameter ‘Type’".

Проблема в том, что для этого кода типы переменных "a" и "b" не совпадают. Компилятор не может однозначно определить какой тип надо передать в качестве значения аргумента "Type". У него есть вариант подставить тип "int" или тип "char". Непонятно какая из подстановок ожидается программистом.

Чтобы избавиться от этой проблемы, можно применить явную передачу типа в шаблон:

const int a = 1; const char bChar = 'b'; const int abMax = max(a, bChar);

Теперь всё хорошо. Шаблонная функция определена однозначно: "int max(int, int)". Значение переменной "bChar" в этом вызове приведётся к типу "int" - так же, как это произошло бы при вызове нешаблонной функции "int max(int, int)" из самого начала статьи.

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

Шаблоны можно использовать не только для функций, но также для классов и структур.

Вот, например, описание шаблонного класса Interval. С его помощью можно описывать промежутки значений произвольного типа:

// Чтобы код собрался нужен будет шаблон "template max(Type, Type)" из // прошлого раздела. Нужно вставить его до шаблона класса. Также по аналогии с // "max<>()" нужно описать шаблон "template min(Type, Type)", возвращающий // меньшее из двух значений. Это будет несложной задачей на дом. template class Interval < public: Interval(Type inStart, Type inEnd) : start(inStart), end(inEnd) < >Type getStart() const < return start; >Type getEnd() const < return end; >Type getSize() const < return (end - start); >// Метод для получения интервала пересечения данного интервала с другим Interval intersection(const Interval& inOther) const < return Interval< max(start, inOther.start), min(end, inOther.end) >; > private: Type start; Type end; >;

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

Пример использование шаблона класса "template class Interval":

int main() < // Тестируем для подстановки типа "int" const IntervalintervalA< 1, 3 >; const Interval intervalB< 2, 4 >; const Interval intersection< intervalA.intersection(intervalB) >; const int intersectionStart = intersection.getStart(); const int intersectionEnd = intersection.getEnd(); const int intersectionSize = intersection.getSize(); // Тестируем для подстановки типа "char" const Interval intervalAChar< 'a', 'c' >; const Interval intervalBChar< 'b', 'd' >; const Interval intersectionChar< intervalAChar.intersection(intervalBChar) >; const char intersectionStartChar = intersectionChar.getStart(); const char intersectionEndChar = intersectionChar.getEnd(); const char intersectionSizeChar = intersectionChar.getSize(); return 0; > // (*) // Небольшая техническая ремарка №1 // Здесь и дальше для классов используется "унифицированная инициализация" // (англ.: "uniform initialization"). Можете поискать о ней информацию. Если // коротко - это часто используемая в индустрии форма записи для // конструкторов/инициализиатора переменных. В фигурных скобках пишут аргументы, // передаваемые в конструктор/инициализиатор. Эту форму можно использовать как // для примитивных типов: // // int unifiedInitializedInt< 0 >; // // так и для классов (пример для структуры описывающей точку в 2D пространстве): // // Point2D unifiedInitializedPoint2D< 1.f, 2.f >; // (*) // Небольшая техническая ремарка №2 // На всякий случай отметим: в примере при создании переменных "intersection" // и "intersectionChar" используется конструктор копирования соответствующих // шаблонных классов. Он не объявлен в шаблоне класса, однако, в C++ конструктор // копирования создаётся по умолчанию. Реализация по умолчанию подходит для // такого простого класса. 

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

// В качестве значения шаблонного аргумента "Type" выполняется подстановка // типа "int". // // Комментариями над методами обозначено как они выглядели в шаблоне до // подстановки. // class Interval  < public: //Interval(Type inStart, Type inEnd) Interval(int inStart, int inEnd) : start(inStart), end(inEnd) < >//Type getStart() const int getStart() const < return start; >//Type getEnd() const int getEnd() const < return end; >//Type getSize() const int getSize() const < return (end - start); >//Interval intersection(const Interval& inOther) const Interval intersection(const Interval& inOther) const < //return Interval< // max(start, inOther.start), // min(end, inOther.end) //>; return Interval< max(start, inOther.start), min(end, inOther.end) >; > private: //Type start; int start; //Type end; int end; >;

Так же, как это было с функциями, порождение шаблонного класса выполнится подстановкой "int" вместо "Type". Порождённый тип будет использоваться везде, где шаблон "template class Interval" с подстановкой "int".

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

4. Специализации

Это, пожалуй, один из самых важных и сложных разделов статьи, поэтому он будет длиннее других.

Лучший пример на котором можно разобраться со специализациями шаблонов - шаблон класса "массив". Вспомним, массив – структура данных, хранящая набор однотипных значений последовательно одно за другим в памяти. В стандартной библиотеке шаблонов эту структуру данных реализует шаблон класса "std::vector<>".

Вот элементарная реализация шаблона массива:

template class SimpleArray < public: // (*) Для простоты, количество элементов будем задавать один раз при создании // массива. Количество элементов определяется аргументом конструктора, оно // неизвестно на этапе компиляции - поэтому элементы создаём на куче, вызовом // оператора "new[]" // // (*) ВАЖНАЯ РЕМАРКА: Здесь и ниже в рамках статьи для простоты опускаются // проверки на создание коллекций нулевого размера. По-хорошему, например, // здесь нужно выполнить проверку "inElementsNum >= 0" и не вызывать оператор // "new" некорректно передавая в него нулевое значение. // SimpleArray(int inElementsNum) : elements(new Type[inElementsNum]), num(inElementsNum) < >int getNum() const < return num; >Type getElement(int inIndex) const < return elements[inIndex]; >void setElement(int inIndex, Type inValue) < elements[inIndex] = inValue; >~SimpleArray() < delete[] elements; >private: Type* elements = nullptr; int num = 0; >;

По реализации, надеюсь, всё понятно. Рассмотрим пример использования:

int main() < SimpleArraysimpleArray< 4 >; simpleArray.setElement(0, 1); simpleArray.setElement(1, 2); simpleArray.setElement(2, 3); simpleArray.setElement(3, 4); int sum = 0; for (int index = 0; index

"SimpleArray" - шаблонный класс, для получения которого в шаблон "template class SimpleArray" в качестве аргумента "Type" передаётся тип "int". Массив заполняется с помощью обращения к методу "setElement()", после чего в цикле рассчитывается сумма всех элементов.

Это рабочий шаблон. Однако есть ситуация, в которой он не достаточно эффективен. Вот пример использования шаблонного класса с подстановкой типа bool:

int main() < SimpleArraysimpleBoolArray< 4 >; simpleArray.setElement(0, true); simpleArray.setElement(1, false); simpleArray.setElement(2, false); simpleArray.setElement(3, true); return 0; >

Элементы массива имеют булевый тип, который выражается одним из всего двух возможных значений: "false" или "true" (численно описывающихся, соответственно, значениями "0" или "1"). Вот как "SimpleArray" использует память для хранения элементов (тут исходим из того, что тип "bool" занимает один байт):

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

C++ задумывался как язык для создания высокоэффективных программ. Поэтому его авторы создали механизм, позволяющий в таких ситуациях добиться большей производительности.

Так появились специализации шаблон ов. Они позволяют описывать вариации шаблонов, которые надо выбирать при передаче в шаблон определённых заданных типов. Например, можно описать вариацию, которая будет выбираться только если в качестве значения шаблонного аргумента передан тип "bool".

Вот по какому принципу описывается специализация:

// У шаблона всегда должно быть привычное нам, обобщённое описание. Оно будет // выбираться при подстановке в случае если ни одна специализация не подойдёт. template class SimpleArray < //. >; // Ниже описывается _специализация шаблона_. В случае, если в SimpleArray в // качестве "Type" передаётся "bool" ("SimpleArray"), будет выбрано именно // это описание шаблона. template<> // [1] class SimpleArray // [2] < //. >; // [1] – тут можно задать дополнительные шаблонные аргументы, от которых // зависит специализация. Этот механизм необходим для более сложных шаблонных // конструкций: для так называемых _частичных специализаций_ (partial // specialization). Мы немного коснёмся этой темы в последнем разделе. // // [2] – тут определяется, собственно, правило выбора данной специализации. В // данном случае оно очень простое: специализация выбирается если в качестве // значения шаблонного аргумента "Type" в "template class SimpleArray" // передаётся тип "bool". // // Специализаций по разным типам может быть сколько угодно. Например, если бы // это имело смысл, можно было бы описать ещё одну специализацию: // // template<> // class SimpleArray // < // //. // >; // // Она выбиралась бы, если бы в качестве "Type" передавался тип "int".

Ниже - полный код специализации шаблона класса "template class SimpleArray".

// (*) Вспомогательная структура "BitArrayAccessData" хранит информацию для // доступа к битам в специализации "SimpleArray". Суть этой информации // описана ниже, в комментарии к методу "SimpleArray::getAccessData()". struct BitArrayAccessData < int byteIndex = 0; int bitIndexInByte = 0; >; // Специализация ниже будет выбрана, если в качестве значения шаблонного аргумента // "Type" передаётся тип "bool". template<> class SimpleArray < public: // (*) Для хранения битов будет использовать массив "unsigned char", так как // этот тип занимает один байт во всех популярных компиляторах. SimpleArray(int inElementsNum) : elementsMemory(nullptr), num(inElementsNum) < // (*) Специализация подчиняется тем же правилам, что и обобщённая версия // шаблона. Она будет содержать количество элементов передаваемое в // конструктор. В конструкторе считается количество байт нужных для // размещения битов элементов. // (*) Для начала расчитывается в каком байте и по какому биту в этом байте // будет размещаться значение последнего элемента массива. Подробнее эта // логика описана в реализации "SimpleArray::getAccessData()". const int lastIndex = (inElementsNum - 1); const BitArrayAccessData lastElementAccessData = getAccessData(lastIndex); // (*) После этого выделяется количество байт достаточное, чтобы запрос // байт по последнему индексу был корректным. Так как индексы начинаются с // нулевого, надо прибавить единицу к индексу чтобы доступ к байту по этому // индексу был корректным. const int neededBytesNum = lastElementAccessData.byteIndex + 1; elementsMemory = new unsigned char[neededBytesNum]; // (*) Стоит отметить, что при размерах не кратных восьми, в последнем // байте битового массива часть битов будет оставаться неиспользованной. // Однако этот вариант намного лучше чем старый. В нём неэффективно // используются лишь биты последнего байта (причём, не больше семи бит). > int getNum() const < return num; >bool getElement(int inIndex) const < // (*) Получение элемента по битовой маске. В начале берётся индекс байта, // в котором находится значение элемента. Потом по номеру бита, берётся бит // в этом байте (как именно - можно почитать под катом ниже данного кода). const BitArrayAccessData accessData = getAccessData(inIndex); const unsigned char elementMask = (1 void setElement(int inIndex, bool inValue) const < const BitArrayAccessData accessData = getAccessData(inIndex); const unsigned char elementMask = (1 ~SimpleArray() < delete[] elementsMemory; >private: // (*) // Функция формирования данных для доступа к битам массива. // В начале вычисляется индекс байта, в котором ищется значение элемента: // // inIndex / sizeof(unsigned char) // // Потом, вычитанием из индекса элемента количества полных бит в байтах до // байта с интересующем нас значением, получается индекс бита в этом байте: // // inIndex - byteIndex* sizeof(unsigned char) // // Звучит запутанно. Лучше логику получения индексов можно понять из следующей // иллюстрации. В поля BitArrayElementAccessData будут записываться значения // "индекс байта" и "индекс бита в байте": // // Индексы. // . сквозных битов |0 1 2 3 4 5 6 7|8 9 10 11 12 13 14 15| // . байтов: | 0 | 1 | --> byteIndex // . битов в байтах |0 1 2 3 4 5 6 7|0 1 2 3 4 5 6 7 | --> bitIndexInByte // static BitArrayAccessData getAccessData(int inElementIndex) < BitArrayAccessData result; result.byteIndex = inElementIndex / 8; result.bitIndexInByte = inElementIndex - result.byteIndex * 8; return result; >unsigned char* elementsMemory = nullptr; int num = 0; >; 

(*) Ликбез по побитным операциям

Для доступа к битам используются следующие побитовые операции:

  1. Операция побитового сдвига влево ( <<)
  2. Операция побитового "И" (&)
  3. Операция побитового "ИЛИ" (|)
  4. Операция побитового отрицания (~)

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

Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1

Как получить значение бита с заданым индексом? Значение бита может быть либо "0", либо "1", поэтому для его выражения используют тип "bool". "bool" имеет смысл "ложь" если все его биты равны "0" и смысл "истина" если хотя бы один его бит не равен "0". Таким образом, чтобы понять имеет ли интересующий нас бит значение "0" или "1", надо добиться того чтобы все биты кроме интересующего нас приняли значение "0". Для этого используются так называемые битовые маски - значения которыми "фильтруются" интересующие нас биты.

Например, надо получить значение бита с индексом "4". Для того чтобы "обнулить" значения всех битов кроме интересующего, формируется битвая маска в которой бит по индексу "4" имеет значение "1", а все остальные биты - значение "0". После этого, выполнив побитовое "И" каждого бита значения с битами маски можно добиться того чтобы все биты кроме интересующего гарантированно стали равны "0":

Получение бита 4

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & Биты маски: 0 0 0 0 1 0 0 0 --------------- Результат: 0 0 0 0 1 0 0 0 = true ^

Получение бита 0

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & Биты маски: 1 0 0 0 0 0 0 0 --------------- Результат: 1 0 0 0 0 0 0 0 = true ^

Получение бита 5

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & Биты маски: 0 0 0 0 0 1 0 0 --------------- Результат: 0 0 0 0 0 0 0 0 = false ^

Получение бита 1

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & Биты маски: 0 1 0 0 0 0 0 0 --------------- Результат: 0 0 0 0 0 0 0 0 = false ^

Разберём обобщённый алгоритм. Как понятно из примеров, чтобы получить значение бита по индексу "bitIndex", надо выполнить операцию побитового "И" между значением и маской, в которой бит по индексу "bitIndex" имеет значение "1", а остальные биты - значение "0". В коде эта логика записывается следующим образом:

// В "value" хранится значение из которого мы извлекаем биты. // Используется битовая запись значения, для компиляции требуется // поддержка C++14 const unsigned char value = 0b1001'1001; // Индекс бита который нужно получить const int bitIndex = 4; // В строчке ниже - формирование маски. Для этого используется // операция побитового сдвига влево на значение индекса. Побитовый // сдвиг возвращает значение, равное значению первого операнда с // каждым битом перемещённым в сторону старших битов на количество // битов равное значению второго операнда. Младшие биты при этом // заполняются нулями. // // Примеры: // "00000001 

Как читать биты терерь известно.

Однако, как заполнить бит в байте по индексу нужным значением? Эту операцию лучше всего выполнять в два этапа:

  1. Значение нужного бита в байте "сбрасывается" в "0". Этого добиваются выполняя логическое "И" между изменяемым байтом и маской в которой бит по целевому индексу имеет значение "0", а все остальные биты - значение "1".
  2. Сброшенное в "0" значение нужного бита "записываются" нужным значением. Это достигается выполнением логического "ИЛИ" между результатом первого этапа и маской в которой по целевому индексу находится значение "1", а все остальные биты имеют значение "0".

Звучит сложно. Чтобы понять как это работает проще всего будет рассмотреть несколько примеров (в скобках записывается с какого на какое значение бита происходит изменение):

Заполнение бита 2 значением 1 (0 -> 1)

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & "Сбрасывающая" маска: 1 1 0 1 1 1 1 1 - - - - - - - - Биты после сброса: 1 0 0 1 1 0 0 1 | | | | | | | | "Записывающая" маска: 0 0 1 0 0 0 0 0 

Заполнение бита 7 значением 0 (1 -> 0)

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & "Сбрасывающая" маска: 1 1 1 1 1 1 1 0 - - - - - - - - Биты после сброса: 1 0 0 1 1 0 0 0 | | | | | | | | "Записывающая" маска: 0 0 0 0 0 0 0 0 

Заполнение бита 6 значением 0 (0 -> 0)

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & "Сбрасывающая" маска: 1 1 1 1 1 1 0 1 - - - - - - - - Биты после сброса: 1 0 0 1 1 0 0 1 | | | | | | | | "Записывающая" маска: 0 0 0 0 0 0 0 0 

Заполнение бита 3 значением 1 (1 -> 1)

 v Индексы битов: 0 1 2 3 4 5 6 7 Биты значения: 1 0 0 1 1 0 0 1 & & & & & & & & "Сбрасывающая" маска: 1 1 1 0 1 1 1 1 - - - - - - - - Биты после сброса: 1 0 0 0 1 0 0 1 | | | | | | | | "Записывающая" маска: 0 0 0 1 0 0 0 0 

В коде эта логика записывается следующим образом (конкретные значения взяты из первого примера с объяснением выставления полей):

unsigned char value = 0b1001'1001; // Индекс бита который нужно получить и значение которое нужно записать const int bitIndex = 2; //В битах "bitValueToSet" будет битовое значение "00000001". // Если бы тут присваивалось значение "false" там было бы битовое // значение "00000000". const bool bitValueToSet = true; // Формируем маски // Дополнительно к побитовому сдвигу который уже использовался раньше // для "сбрасывающей" маски используется унарная операция побитового // отрицания (~). // Она используется чтобы получить сбрасывающую маску. Суть работы // простая - эта операция возвращает значение операнда в котором все // биты инвертированы на противоположное значение (0->1, 1->0). // Например, вот какими будут значения выражений в данном случае: // // "1 

Рассмотрим новый пример использования "template class SimpleArray" с поддержкой специализации по типу "bool":

int main() < SimpleArraysimpleArray< 4 >; simpleArray.setElement(0, 'A'); simpleArray.setElement(1, 'B'); simpleArray.setElement(2, 'C'); simpleArray.setElement(3, 'D'); // // Над комментарием - пример использования специализации // "template class SimpleArray" по типу "char". // // Выбирая шаблонную конструкцию в которую надо подставить тип, компилятор // отбросит специализацию "template<> class SimpleArray" - так как // передаваемый тип не является типом "bool". Других специализаций нет, // компилятор остановит свой выбор на обобщённой версии шаблона: // "template class SimpleArray". Именно она будет использована для // порождения шаблонного класса "SimpleArray" SimpleArray simpleBoolArray< 8 >; simpleBoolArray.setElement(0, true);// 1 simpleBoolArray.setElement(1, false);// 0 simpleBoolArray.setElement(2, false);// 0 simpleBoolArray.setElement(3, true);// 1 simpleBoolArray.setElement(4, true);// 1 simpleBoolArray.setElement(5, false);// 0 simpleBoolArray.setElement(6, false);// 0 simpleBoolArray.setElement(7, true);// 1 // // Над комментарием - пример использования специализации // "template class SimpleArray" по типу "bool". // // Тут компилятор выберет специализацию, ведь подставляемый в шаблон тип // это "bool". Он подходит по описанным правилам для специализации // "template<> class SimpleArray" // Отметим несколько моментов: // // 1. Переменные типа "char" и "bool" обе занимают один байт памяти. // Однако несмотря на это, за счёт использования специализации по типу bool, // "SimpleArray" требует для хранения восьми элементов всего одного // байта (каждый бит которого будет хранить значение одного элемента массива, // то есть, в данном случае, в битах этого байта будет значение "10011001"). // Для хранения же четырёх элементов в "SimpleArray", требуется целых // четыре байта - по одному на каждый элемент типа "char". // За счёт специализации нам действительно удалось сделать массив булевых // переменных в восемь раз компактнее. // // 2. В который раз отметим сущность шаблонных классов. Шаблонные классы // "SimpleArray" и "SimpleArray" - это разные типы. // Они оба породились из шаблона "template class SimpleArray" и, как // будет видно дальше, компилятор может использовать информацию об этом их // "родстве". Однако на шаблонные классы порождённые из одного шаблона стоит // смотреть как на разные типы (потому что это действительно разные типы). return 0; >

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

5. Валидация шаблонных аргументов

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

Что ж. Добавим немного дёгтя.

Уже при описании шаблонной функции "template max(Type, Type)" неминуемо возникал вопрос: как проверяется корректность типа, который подставляется в шаблон? Ведь в шаблоне тип как-то используется. Например, что будет если передать в качестве аргумента "template max(Type, Type)" тип, не поддерживающий оператор "> cpp">template Type max(Type a, Type b) < return (a >= b ? a : b); > // Структура, определяющая позицию точки в двухмерном пространстве. Для точки // нельзя сказать "больше" ли она другой точки. Можно сравнивать конкретные // координаты ("x" или "y") точек, но нельзя сравнить сами точки. Для структуры // Point2D _не определена_ операция сравнения "> Point2D" в аргумент "Type" шаблона // "template max(Type, Type)" породится шаблонная функция, которая для // компилятора выглядит так: // // Point2D max(Point2D a, Point2D b) // < // return (a >= b ? a : b); // > // // В теле функции выполняется сравнение двух значений ("a" и "b") имеющих тип // "Point2D". Однако, как было отмечено выше, для их типа "Point2D" операция // сравнения _не определена_ . Компилятору остаётся лишь сгенерировать ошибку // компиляции вроде следующей (так отображает ошибку компилятор GCC): // // "no match for 'operator

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

Сейчас в промышленно используемом C++ нет механизма валидации шаблонных аргументов.

Долгое время это была одна из главных проблем шаблонов и, в целом, одной из главных проблем языка C++. Особенно ужасно она проявляла себя в сложных шаблонных конструкциях из сторонних библиотек. Там ошибки компиляции могли появляться в глубинах логики чужих шаблонов. Приходилось долго разбираться в реализации стороннего кода. Имевшие дело со стандартной библиотекой шаблонов , с её самыми популярными шаблонами классов "std::vector<>" и "std::map<>", наверняка не раз страдали от многоэтажных ошибок компиляции в недрах их реализаций.

Проблему с валидацией решали по-разному. Использовали свойства подстановок, вводили в язык конструкцию "static_assert()", придумывали стили комментариев, в которых текстом описывались бы требования к аргументам шаблонов.

Лишь спустя годы поисков, к версии C++20 комитет по стандартизации языка прекратил хождение по мукам и наконец-то качественно решил вопрос, введя в язык КОНЦЕПТЫ .

Концепты позволяют описывать требования к типу, который передаётся как шаблонный аргумент. Например, для шаблона функции "template Type max(Type, Type)" с помощью концептов можно потребовать передавать в качестве значения "Type" тип, поддерживающий операцию сравнения. С помощью концептов компилятор может обнаружить ошибку до выполнения некорректной подстановки типа в шаблон.

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

Могу ответственно сделать прогноз: в течение десяти лет шаблоны и концепты выйдут из резервации библиотек и станут ежедневным инструментом прикладного разработчика. Если вы связываете свою профессиональную карьеру с языком C++, изучайте шаблоны и концепты уже сегодня. Не обращайте внимания на скептиков, они тоже когда-то засядут за изучение, будьте же первыми!

На этом закончу пропаганду. Цель статьи - дать вводную начинающим разработчикам, которым предстоит работать с реальным кодом, использующимся в индустрии прямо сейчас. Код этот, увы, написан, в основном, с использованием старых стандартов. Освоим для начала их.

6. Больше шаблонных аргументов

До этого речь шла о шаблонах зависящих от одного аргумента. Но C++ позволяет задавать и большее их количество. Чтобы прочувствовать как это используется в реальном коде, рассмотрим шаблон, зависящий от двух шаблонных аргументов.

В качестве примера опишем очень простую реализацию шаблона класса словарь (известного также как ассоциативный массив или отображение ). Это класс-контейнер, хранящий набор значений, доступ к которым, в отличие от массива, происходит не по индексу (числу выражающему номер элемента), а по ключу (произвольному, уникальному относительно других ключей значению). В стандартной библиотеке шаблонов эту структуру данных реализует шаблон класса "std::map<>".

Ниже представлена элементарная реализация словаря. Использование шаблона позволяет как ключ, так и значение задавать произвольным типом:

// Служебный шаблон структуры для хранения пар "ключ и значение" произвольных // типов. Он понадобится в реализации словаря. Это первое место использования // двух шаблонных аргументов. Первым задаётся тип ключей, вторым - тип значений, // доступ к которым происходит по ключам. Внутри треугольных скобок добавляется // объявление второго шаблонного аргумента-типа который можно использовать в // теле шаблонного класса. template struct KeyAndValue < KeyType key; ValueType value; >; // Собственно, сам шаблон класса "словарь". template class Dictionary < public: // (*) Как и для массива, зафиксируем максимальное возможное количество // элементов при создании. В отличие от массива, мы не можем считать // ассоциативный массив заполненным по умолчанию, так как созданные // по умолчанию элементы-пары массива будут иметь одинаковые ключи, что // нарушает основное свойство словаря (ключи должны быть уникальными). // Поэтому для хранения размеров мы заведём два поля: одно будет хранить // максимальное возможное количество элементов словаря (capacity), второе - // фактическое количество заполненных, значимых элементов (num). Dictionary(int inCapacity) : keysAndValues(new KeyAndValue[inCapacity]), capacity(inCapacity), num(0) < >const ValueType* getValue(KeyType inKey) const < const KeyAndValue* foundKeyAndValue = findPair(inKey); return foundKeyAndValue ? &foundKeyAndValue->value : nullptr; > void setValue(KeyType inKey, ValueType inValueType) < KeyAndValue* keyAndValueToSet = findPair(inKey); // (*) Если по ключу в массиве нет пары ключ-значение - добавляем новую if (!keyAndValueToSet) < // (*) Минимальная проверка: не достигли ли мы максимального // количества элементов в словаре. В промышленном коде тут бы // использовались исключения (exceptions). if (num == capacity) return; keyAndValueToSet = &keysAndValues[num]; keyAndValueToSet->key = inKey; ++num; > keyAndValueToSet->value = inValueType; > ~Dictionary() < delete[] keysAndValues; >private: const KeyAndValue* findPair(KeyType inKey) const < for (int index = 0; index < num; ++index) if (keysAndValues[index].key == inKey) return &keysAndValues[index]; return nullptr; >// (*) Мутирующая версия геттера пары нужна для метода "setElement()". // Фактически, всё что он делает можно описать следующим псевдокодом: // "const_cast(const_cast(this)->findPair(. ))". Это стандартный приём // который позволяет избежать дублирования кода при необходимости // одинаковой логики для константного и мутирующего доступа к состоянию // объекта. Подробнее об этом мы поговорим следующей в статье при // возможности применения шаблонов. KeyAndValue* findPair(KeyType inKey) < const Dictionary* constThis = const_cast(this); const KeyAndValue* constResult = constThis->findPair(inKey); return const_cast(constResult); > KeyAndValue* keysAndValues = nullptr; int capacity = 0; int num = 0; >;

Пример, иллюстрирующий использование шаблона:

int main() < // Пример словаря, позволяющего получать доступ к булевым флагам по // целочисленным значениям - шаблонный класс "Dictionary" Dictionary dictionary< 2 >; dictionary.setValue(1, false); dictionary.setValue(3, true); //Переменные ниже будут иметь, соответственно, следующие значения: // value1 - указатель на булеву переменную со значением false // value2 - нулевой указатель, по ключу 2 в словаре не задавалось значение // value3 - указатель на булеву переменную со значением true const bool* value1 = dictionary.getValue(1); const bool* value2 = dictionary.getValue(2); const bool* value3 = dictionary.getValue(3); // Пример использования шаблонного класса "Dictionary", // позволяющего получить символ, которым обозначается число в тексте [1]. Dictionary dictionaryChar< 3 >; dictionaryChar.setValue(1, '1'); dictionaryChar.setValue(2, '2'); dictionaryChar.setValue(3, '3'); //Переменные ниже будут иметь, соответственно, следующие значения: // value1Char - указатель на "char" со значением '1' // value2Char - указатель на "char" со значением '2' // value3Char - указатель на "char" со значением '3' const char* value1Char = dictionaryChar.getValue(1); const char* value2Char = dictionaryChar.getValue(2); const char* value3Char = dictionaryChar.getValue(3); return 0; > // [1] - (*) данный код стоит рассматривать исключительно как пример, не стоит // применять словари таким образом в промышленном программировании. Отображать // числа в символьное представление лучше используя ASCII значение // (будет работать если значение "numberValue" в промежутке [0, 9]): // // int numberValue = 5; // char numberChar = '0' + numberValue;

В случае необходимости возможно описывать шаблоны и от большего количества аргументов. Начиная с версии C++11 вообще возможно описывать шаблоны от произвольного количества аргументов , использующие пакеты параметров . Это важный механизм, вместе с move-семантикой и range-based for, сделавший стандарт C++11 базовым в современной разработке.

К сожалению, тема шаблонов от произвольного количества аргументов слишком обширная. В данной статье мы её касаться не будем. Если когда-нибудь напишу материал по теме - обязательно оставлю здесь ссылку на него.

7. Шаблонные аргументы-константы

До этого рассматривались шаблоны, принимающие лишь типы в качестве шаблонных аргументов. Однако в качестве аргументов шаблонов могут выступать также константы времени компиляции. Такие аргументы по-английски называются non-type template arguments, дословно "шаблонные аргументы не являющиеся типами". Дословный перевод по-русски звучит неуклюже, поэтому дальше будем использовать термин " шаблонные аргументы-константы ".

Рассмотрим синтаксис использования таких аргументов на небольшом примере, который, несмотря на слегка безумную реализацию, демонстирует сразу несколько аспектов использования шаблонных аргументов-констант. Реализуем шаблон функции для расчёта факториала на шаблонных аргументах:

// Синтаксис объявления шаблонного аргумента-константы выглядит очень похожим // на синтаксис объявления аргументов-типов. Вместо ключевого слова "typename" // записывается тип, который имеет константа. В данном случае, зададим число от // которого считается факториал типом "int", а аргумент назовём "Value". // После объявления аргумента можно использовать его в теле шаблона функции как // обычную константу. template int getFactorial() < // Мы считаем факториал рекурсивным вызовом _другой шаблонной функции_, // получаемой _из этого же шаблона функции_ передачей в качестве // значения шаблонного аргумента значения "Value - 1". То есть из вызова // "getFactorial()" будет вызываться "getFactorial()", из него - // "getFactorial()" и т.д. // Ниже, в "main()" подробно разбирается как будет работать данный шаблон // функции. return Value * getFactorial(); > // Специализации возможно использовать с шаблонными аргументами-константами // так же, как с аргументами-типами. В данном случае мы описываем // специализацию шаблона "template int getFactorial()" по значению // шаблонного аргумента "Value", условие выбора специализации - равенство // значения шаблонного аргумента числу "1". Значение, по которому будет // выбираться специализация записывается так же, как это делалось для // специализаций по типам, с той разницей, что для аргументов-констант мы пишем, // собственно, значение константы. template<> int getFactorial() < return 1; >int main() < // Чтобы понять как работает данная реализация факториала рассмотрим как // компилятор выполняет данный вызов. // // 1. Встретив запись getFactorial() компилятор обратится к описанию // шаблона функции "template int getFactorial()". У шаблона есть // одна специализация - по равенству значения аргумента Value единице: // "template<> int getFactorial()". В вызов передано значение 4, значит // специализация не подходит и компилятор выберет обобщённую версию шаблона. // В порождённой шаблонной функции "getFactorial()" вызывается // "getFactorial()", то есть "getFactorial()" // // 2. С "getFactorial()" всё будет аналогично пункту 1. Специализация по // равенству Value единице не подойдёт, порождённая функция // "getFactorial()" будет содержать вызов "getFactorial()". // // 3. Для "getFactorial()" специализация по равенству "Value" единице // также не подходит. Порождённая функция "getFactorial()" будет содержать в // в реализации вызов "getFactorial()". И вот тут, наконец-то, будет // выбрана специализация "template<> int getFactorial()", которая вернёт // константу "1". С этого места начнётся возврат из "рекурсивного" вызова. // // Слово "рекурсивный" записано в кавычках, потому что тут мы имеем дело с // непривычной рекурсией. Функция "getFactorial()" вызывает функцию // "getFactorial()", та вызывает "getFactorial()" и та, наконец, // вызывает "getFactorial()". и все четыре эти функции порождённые из // "template int getFactorial()" - это разные функции. Как в // прошлых примерах со специализациями по типам, из шаблонов функций с // аргументами-константами будут получаться разные шаблонные функции // подстановкой разных констант. const int factorial4Result = getFactorial(); return 0; >

За счёт того, что значение шаблонного аргумента-константы по определению не зависит от вычислений этапа исполнения программы, компилятор с большой вероятностью сможет оптимизировать код при компиляции, подставив в ассемблерном коде константу 4*3*2*1 (то есть, сразу значение 24), вместо полноценного вызова функции "getFactorial()" и всей содержащейся в ней логики.

Рассмотрим какие ещё варианты передачи значения шаблонного аргумента-константы допустимы:

int main() < const int constVariable = 4; const int factorial1 = getFactorial(); // // Код выше скомпилируется успешно. Тип переменной constVariable помечен // как const и не зависит от переменных времени исполнения - поэтому его // можно передать в качестве значения шаблонного аргумента-константы int mutableVariable = 4; //const int factorial2 = getFactorial(); // // Код выше не скомпилируется с ошибкой: "the value of ‘mutableVariable’ // is not usable in a constant expression". Передавать переменные в // getFactorial<>() нельзя, так как mutableVariable не помечена как const и // является для компилятора значением времени исполнения. int a = 1; int b = 3; const int constVariableFromMutableVariables = a + b; //const int factorial3 = getFactorial(); // // Код выше не скомпилируется с той же ошибкой. Несмотря на то, что // "constVariableFromMutableVariables" помечена как "const", её значение // зависит от переменных "a" и "b", которые могут меняться во время // исполнения программы. Это превращает её из константы времени компиляции в // переменную времени исполнения. Да, она помечена как неизменная. Но в // данном случае, для компилятора это лишь "обещание", что переменная не // будет меняться после инициализации значением "a+b" и компилятор может // попытаться выполнить какие-то оптимизации опираясь на эту информацию. const int constA = 1; const int constB = 3; const int constVariableFromConstVariables = constA + constB; const int factorial4 = getFactorial(); // // А вот этот код скомпилируется успешно. constVariableFromConstVariables // зависит только от константных значений времени компиляции. return 0; >

Cтоит отметить: в реальном коде редко когда стоит таким образом реализовывать вычисление факториала. Да, при правильной доработке эта реализация идеально оптимизирована. Но программы почти всегда оперируют значениями времени исполнения, которые нельзя передать в качестве значений шаблонных аргументов-констант. Этот пример стоит воспринимать скорее как иллюстрацию логики работы шаблонных аргументов-констант.

В разделе "Частичные специализации шаблонов" будет ещё один пример, использующий шаблонные аргументы-константы. Он ближе к реальной жизни.

8. Передача шаблонных аргументов в шаблонном контексте

Вероятно, в разделе про шаблонные классы у читающего мог возникнуть резонный вопрос: можно ли передать шаблонный класс в функцию, сохранив код обобщённым? Например, возможно ли описать функцию для получениея максимального элемента в шаблонном массиве "template SimpleArray".

Можно начать плодить перегрузки с конкретными шаблонными классами:

// Используем шаблон функции "template Type max(Type, Type)" из первого // раздела и шаблон класса "template class SimpleArray" из четвёртого. // Перегрузка функции для шаблонного класса "SimpleArray" int getMaxElement(const SimpleArray& inArray) < // (*) Как отмечалось, проверки на пустые коллекции в статье опускаются. // В релизном коде тут следовало бы проверить "inArray.getNum() >0" и вызвать // исключение (или как-то ещё вернуть ошибку) если функция выполняется для // пустой коллекции. // Отметим - у переменной "maxElement" тип "int", ведь шаблонный массив // "SimpleArray" хранит внутри типы "int" int maxElement = inArray.getElement(0); for (int index = 1; index < inArray.getNum(); ++index) maxElement = max(maxElement, inArray.getElement(index)); return maxElement; >// Копия той же логики, но для шаблонного класса "SimpleArray". На всякий // случай, отмечу в который раз - здесь _не будет_ ошибки перегрузки, так как // типы "SimpleArray" и "SimpleArray" это два разных типа, пусть и // порождены они из одного шаблона класса. char getMaxElement(const SimpleArray& inArray) < // Тип "char", ведь массив "SimpleArray" содержит элементы этого типа. char maxElement = inArray.getElement(0); for (int index = 1; index < inArray.getNum(); ++index) maxElement = max(maxElement, inArray.getElement(index)); return maxElement; >// . и так далее, копирование одного и того же кода с точностью до типа // подстановки в SimpleArray.

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

Что ж, C++ позволяет использовать шаблон и в такой ситуации. На самом деле, случаи нужного нам типа подстановок встречались в статье раньше, просто внимание на них не акцентировалось. Вот, к примеру, метод шаблона "template class Interval":

template class Interval < //. // Шаблонный аргумент передаётся в "Interval". Шаблонный аргумент "Type" // в теле шаблона "template class Interval" можно использовать любым // образом, в том числе для подобной подстановки - как значение шаблонного // аргумента метода. Interval intersection(const Interval& inOther) const < return Interval< max(start, inOther.start), min(end, inOther.end) >; > //. >;

Вместо повторяющихся перегрузок "getMaxElement()", можно описать шаблон функции, аргумент которой передаётся в шаблон класса "template class SimpleArray":

// Один шаблон функции "getMaxElement()" вместо повторяющейся одной и той же // логики. Использует подстановку "Type" в шаблон "template SimpleArray" template Type getMaxElement(const SimpleArray& inArray) < Type maxElement = inArray.getElement(0); for (int index = 1; index < inArray.getNum(); ++index) maxElement = max(maxElement, inArray.getElement(index)); return maxElement; >// Сразу рассмотрим пример использования функции: int main() < // --- Пример с шаблонным классом SimpleArray--- SimpleArray intArray< 2 >; intArray.setElement(0, 2); intArray.setElement(1, 1); // Тут мы выполняем явную передачу шаблонного аргумента в шаблон функции. int intMax = getMaxElement(intArray); // --- Пример с шаблонным классом SimpleArray --- SimpleArray charArray< 3 >; charArray.setElement(0, 'c'); charArray.setElement(1, 'b'); charArray.setElement(2, 'a'); char charMax = getMaxElement(charArray); // // Функция вызывается без явной передачи значения шаблонного аргумента. Это // будет работать. Рассмотренный во втором разделе механизм вывода типов // настолько умён, что даже в такой ситуации способен сам вывести тип "Type" // шаблона функции "getMaxElement()" из типа передаваемого в функцию // аргумента. Для вычисления значения шаблонного аргумента компилятор выполнит // следующий анализ: // // 1. Передаваемая в функцию переменная "charArray" имеет тип // "SimpleArray". // // 2. В качестве аргумента (нешаблонного) шаблона функции "getMaxElement<>()" // ожидается "const SimpleArray&". // // 3. Если "наложить" передаваемый в функцию тип "SimpleArray" на // шаблонную конструкцию "const SimpleArray&", можно сделать вывод, что // при передаче типа "char" в качестве "Type" вызов шаблонной функции // "getMaxElement(charArray)" будет корректен. // // 4. Компилятор самостоятельно подставляет тип "char" в качестве значения // шаблонного аргумента "Type". return 0; > 

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

9. Частичные специализации шаблонов

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

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

В шаблоне класса "template SimpleArray" использовалась динамическая память:

template class SimpleArray < //. // (*) Динамическая память для элементов выделяется вызовом "new[]" SimpleArray(int inElementsNum) : elements(new Type[inElementsNum]), num(inElementsNum) < >//. // (*) Динамическая память освобождается вызовом оператора "delete[]" ~SimpleArray() < delete[] elements; >//. >;

Использование динамической памяти позволяло создавать массивы разной длины, определяемой на этапе исполнения программы:

int main() < int firstElementsNum = 1, secondElementsNum = 2; // Изменяем значения переменных во время исполнения. ++firstElementsNum; ++secondElementsNum; // Два экземпляра одного шаблонного класса "SimpleArray": // "first" длиной в два элемента, "second" - длиной в пять (2+3). Длина // может вычисляться во время исполнения программы. SimpleArray first< firstElementsNum >; SimpleArray second< firstElementsNum + secondElementsNum >; return 0; >

Память для элементов выделяется единожды, при создании экземпляров. После этого расширить или сократить объём памяти нельзя. Так ли важна эта возможность?

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

int main() < int arrayStack[3]< 1, 2, 3 >; // // Выше объявлен буфер из элементов распологающихся на стеке. Его размер // известен во время компиляции (размер "int" умноженный на размер массива, 3). // Выделение и освобождение памяти для "arrayStack" практически бесплатное. // Для выделения размер массива прибавляется к счётчику, который хранит смещение // вершины стека, для освобождения - этот размер отнимается от счётчика. int* arrayHeap = new int[3]< 1, 2, 3 >; delete[] arrayHeap; // // Выше выполняется создание буфера в динамической памяти. Размер и наполнение // будет идентично "arrayStack". Однако количество действий для выделения и // освобождения памяти будет намного большее: // 1. При вызове "new int[3]" аллокатор по умолчанию (default allocator) // выполнит поиск в динамической памяти блока нужного для буфера размера // (размер "int" умноженный на размер массива, 3). Поиск будет требовать // определённых ресурсов времени исполнения. // 2. Найденный блок будет помечен как занятый и адрес блока памяти запишется // в переменную-указатель "arrayHeap". Так как запрашиваемый блок имеет // небольшой размер, это будет вызывать фрагментацию памяти [*]. // 3. Освобождение динамической памяти тоже не "бесплатное". При вызове // оператора "delete[]", аллокатор должен пометить блок памяти занимаемый // буфером как свободный. return 0; > // __________________ // [*] - фрагментация памяти - ситуация когда выделяется много маленьких блоков // памяти из-за чего повышается сложность поиска одного большого блока.

Иллюстрация принципа работы стека и динамической памяти

Картинка, иллюстрирующая принцип работы кучи и стека. Цветные элементы со знаками "+" и "-" иллюстрируют принцип по которым работает, соответственно, выделение и освобождение памяти этих типов.

Блоки памяти в стеке выделяются простым сдвигом вершины стека.

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

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

Можно сравнить ассемблерный код который получится при компиляции примера:

Уже по количеству команд для записи значений элементов видно что использование динамической памяти требует большего количества действий. Однако "call" вызовы для создания и освобождения динамической памяти - это ещё более тяжёлые операции обращения к функциям.

Было бы здорово получить структуру данных, хранящую элементы в стековой памяти. В стандартной библиотеке шаблонов такую структуру реализует шаблон "std::array<>".

Чтобы подобную структуру данных получить из "template SimpleArray", надо сменить тип поля для хранения элементов массива:

// Новый шаблон класса не позволяет задавать количество элементов во время // исполнения программы. Так как поведение нового шаблона отличается от старого, // лучше назвать шаблон по-другому: "template SimpleStaticArray". template class SimpleStaticArray < //. private: // ! В коде ниже значение "Size" должно быть известно на этапе компиляции ! Type elements[Size]; // ;

Чтобы это работало, количество элементов массива (значение "Size") надо передавать константой времени компиляции. Такой мехнизм уже известен: константы времени компиляции передаются в шаблоны с помощью шаблонных аргументов-констант. Добавим шаблонный аргумент-константу:

// Добавляем шаблонный аргумент-константу "Size" в котором передаётся количество // элементов массива. template class SimpleStaticArray < //. private: Type elements[Size]; // От поля "num" теперь можно в принципе отказаться. Длина массива - это // значение шаблонного аргумента-константы "Size", он доступен в классе. >;

Вот полная реализация обобщённого шаблона класса. Она очень простая:

template class SimpleStaticArray < public: SimpleStaticArray() : elements() < >int getNum() const < // Как писалось выше, количество элементов теперь доступно в шаблонном // аргументе-константе. return Size; >Type getElement(int inIndex) const < return elements[inIndex]; >void setElement(int inIndex, Type inValue) < elements[inIndex] = inValue; >private: Type elements[Size]; >;

Теперь внимательному читателю, вероятно, интересно: что же будет со специализацией по типу "bool"? Она, с одной стороны, требует "фиксации" значения первого шаблонного аргумента "Type", с другой - должна поддерживать произвольное значение второго аргумента "Size" (массив флагов может быть любой длины).

Для решения этого вопроса существуют частичные специализации шаблонов :

template class SimpleStaticArray < // Тут должна быть реализация обобщённой версии шаблона, см. выше >; // В реализации используется "BitArrayAccessData" из четвёртого раздела, вместо // данного комментария надо будет вставить описание этого шаблона структуры. // Специализация должна выбираться при любом значении второго шаблонного // аргумента-константы "Size" и при передаче строго конкретного значения "bool" в // качестве первого аргумента. В строке [1] задаётся _аргумент специализации_, // который _исключительно для данной специализации_ описывает обобщённое // произвольное значение которое может иметь второй аргумент шаблона при // подстановке. Аргумент используется в строке [2]. При этом в той же строке // "фиксируется" значением "bool" первый аргумент. // template //[1] class SimpleStaticArray //[2] < public: SimpleStaticArray() : elementsMemory() < >int getNum() const < // Количество элементов возвращаем по тому же принципу что и для обобщённой // версии шаблона - возвращаем значение шаблонного аргумента. return Size; >// Все методы ниже остаются такими же, какими они были в четвёртом разделе, // поменялось лишь размещение памяти для элементов, логики это не коснулось. bool getElement(int inIndex) const < const BitArrayAccessData accessData = getAccessData(inIndex); const unsigned char elementMask = (1 void setElement(int inIndex, bool inValue) < const BitArrayAccessData accessData = getAccessData(inIndex); const unsigned char elementMask = (1 private: static BitArrayAccessData getAccessData(int inElementIndex) < BitArrayAccessData result; result.byteIndex = inElementIndex / 8; result.bitIndexInByte = inElementIndex - result.byteIndex * 8; return result; >// (*) При объявлении типа поля "elementsMemory" нужно посчитать количество // байт нужных для хранения элементов. Значение будет вычисляться на этапе // компиляции при порождении подстановки для нового значения шаблонного // аргумента "Size". Принцип по которому выполняется расчёт можно найти в // комментарии к логике конструктора шаблона класса // "template class SimpleStaticArray" из начала четвёртого раздела. unsigned char elementsMemory[Size / (sizeof(unsigned char) * 8) + 1]; >;

Рассмотрим пример использования, аналогичный примеру из четвёртого раздела, разобрав логику по которой компилятор будет выбирать специализацию:

int main() < SimpleStaticArraysimpleArray< >; simpleArray.setElement(0, 'A'); simpleArray.setElement(1, 'B'); simpleArray.setElement(2, 'C'); simpleArray.setElement(3, 'D'); // // Над комментарием - пример использования специализации // "template class SimpleStaticArray" по типу "char" // и размером "Size" в четыре элемента. // // Выбирая шаблонную конструкцию в которую надо подставить тип, компилятор // отбросит специализацию "template class SimpleStaticArray". // Передаваемый тип не является типом "bool". За неимением других специализаций, // компилятор остановит свой выбор на обобщённой версии шаблона: // "template class SimpleStaticArray". Именно она будет // использована для порождения шаблонного класса // "SimpleStaticArray". SimpleStaticArray simpleBoolArray< >; simpleBoolArray.setElement(0, true);// 1 simpleBoolArray.setElement(1, false);// 0 simpleBoolArray.setElement(2, false);// 0 simpleBoolArray.setElement(3, true);// 1 simpleBoolArray.setElement(4, true);// 1 simpleBoolArray.setElement(5, false);// 0 simpleBoolArray.setElement(6, false);// 0 simpleBoolArray.setElement(7, true);// 1 // // Над комментарием - пример использования специализации // "template class SimpleStaticArray" по типу "bool". Специализация // будет выбрана, так как первый аргумент имеет значение "bool" (что // удовлетворяет условию выбора специализации), а второй аргумент в // специализации не фиксирован никакими правилами в специализации. // Для всех подстановок ниже будут порождаться шаблонные классы, использующие // при порождении всё ту же специализацию по типу "bool", все они подходят // по условию, несмотря на разные значения второго шаблонного аргумента: SimpleStaticArray simpleBoolArraySixElements< >; SimpleStaticArray simpleBoolArrayFourElements< >; SimpleStaticArray simpleBoolArrayTwentyElements< >; // Также важно отметить что в этом примере порождается много разных шаблонных // классов: // // SimpleStaticArray // SimpleStaticArray // SimpleStaticArray // SimpleStaticArray // SimpleStaticArray // // Это всё _разные типы_. При неосторожном использовании специализации могут // увеличивать объём бинарного кода после компиляции. Эта тема подробнее // разобрана в секции часто задаваемых вопросов в конце статьи. return 0; >

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

Увы, частичные специализации не поддерживаются шаблонами функций:

 template ResultType getFactorial() < ResultType result = 1; for (int currentValue = 2; currentValue < Value; ++currentValue) < result *= currentValue; >return result; > // Специализации ниже не скомпилируются из-за того, что C++ не поддерживает // частичные специализации функций: // //template //() // < // return 1; //>//template //() // < // return 1; //>// --------------------- int main() < short int result0 = getFactorial(); short int result1 = getFactorial(); int result8 = getFactorial(); return 0; >

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

Заключение

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

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

Updated: Если вас заинтересовала тема шаблонов в C++, уже сейчас есть хорошая статья от @4eyes, рассматривающая более продвинутые техники метапрограммирования на практическом примере: "О шаблонах чуть сложнее".

1. Вопрос: Чем шаблоны отличаются от макросов?

Ответ: Макросы выполняют текстовую подстановку аргументов, в то время как шаблоны лексически и синтаксически проверяются компилятором. Если для решения задачи стоит выбор между шаблонами и макросы - стоит предпочитать шаблоны.

Эти вопросы логично возникают у программистов, изучающих шаблоны. Действительно, на первый взгляд, шаблоны похожи на макроподстановки компиляторов. Оба механизма позволяют "генерировать" код по определённому трафарету с подстановкой передаваемых по месту применения значений-аргументов.

Главная разница заключается в том, что макросы - это действия с текстом, который не воспринимается компилятором как исходный код состоящий из определения функций, переменных, выражений, и т.д. С текстом программы работает препроцессор, для которого программа - набор символов (букв, цифр, знаков для операторов, пробелов, и т.д.), которые можно копировать и вставлять полностью аналогично тому как программист это делает в IDE с помощью Ctrl+C, Ctrl+V:

  • #include - указание "вставить вместо макроса весь текст содержащийся в файле"
  • #define - указание "встречая идентификатор определяющий макрос, вставить текст следующий за макросом с заменой аргументов передаваемым по месту использования текстом".
  • и т.д.

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

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

Допустим, имеется следующие фукнции для работы с файлами, содержащими числа:

// Функция, переоткрывающая файл для считывания значений начиная с // первого. void reopen(const char* fileName); // Функция, с помощью которой мы читаем из файла расположенные одно за // другим численные значения. Возвращает считанное из файла число и, // что важно, _передвигает каретку_ считывания значения на следующее // место. То есть, если в файле хранятся значения: "1, 2, 3" - то при // первом вызове "loadNextValueFromFile()" вернёт 1, при втором 2, при // третьем 3. int loadNextValueFromFile(const char* fileName); // Функция возвращающая "true", если файл прочитан до конца и "false", // если нет. bool isEndOfFile(const char* fileName);

Задача следующая - надо найти максимальное число в файле.

Для начала рассмотрим как в этой задаче сработает обобщённая логика для поиска максимального значения, описанная с помощью макроса:

#define MAX(A, B) (A >= B) ? A : B //. int main() < reopen("file"); if (!endOfFile("file")) < int currentMax = loadNextValueFromFile("file"); while (!endOfFile("file")) currentMax = MAX(currentMax, loadNextValueFromFile("file")); >return 0; >

На первый взгляд, логика должна работать корректно.

Однако давайте посмотрим в какой код буквально раскроется строчка с макросом:

// Вот код до выполнения макроподстановки: // // currentMax = MAX(currentMax, loadNextValueFromFile("file")); // // Во время подстановки значения макроса, препроцессор буквально // вставит следующий текст: "(A >= B) ? A : B", подставив буквально // текст "currentMax" вместо аргумента макроса "A" и, буквально, // текст "loadNextValueFromFile("file")" вместо аргумента "B" // // Получится следующее: currentMax = (currentMax >= loadNextValueFromFile("file")) ? currentMax : loadNextValueFromFile("file");

Именно с таким кодом функция "main()" отправится на компиляцию. Если обратить внимание на то как работает функция "loadNextValueFromFile()" и внимательно вчитаться в то что сгенерировал препроцессор, в программе можно увидеть неприятный баг.

Вот как выполнится логика алгоритма если в файле содержатся числа "1, 3, 0":

  1. Записываем в currentMax первое число из файла (число "1").
  2. Вычисляем результат сравнения " currentMax >= loadNextValueFromFile("file") " - причём из-за вызова функции чтения из файла каретка для чтения перемещается на следующее число .
    Результат проверки - текущее значение currentMax (число "1") меньше чем взятое из файла (число "3"), тернарный оператор должен вернуть значение по условию "false".
  3. Для расчёта значения по условию "false" снова вызывается "loadNextValueFromFile("file")". Этот вызов вернёт число "0", так как каретка передвинулась при вычислении сравнения. В currentMax записывается число "0", которое, очевидно, не является самым большим в файле.

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

Из-за примитивности механизма работы препроцессора, использование макросов в прикладном коде будет стабильно приводить к подобным трудно уловимым ошибкам.

Поэтому лучше предпочитать макросам шаблоны:

template Type max(Type a, Type b) < return (a >= b ? a : b); > //. int main() < reopen("file"); int currentMax = 0; while (!endOfFile("file")) < // Используем шаблон "templatemax(Type, Type)" с // подстановкой типа "int". Здесь возможен автоматический // вывод типа: оба передаваемых в функцию значения имеют // одинаковый тип "int" - однако подчеркнём явной передачей, // что здесь используется шаблон. currentMax = max(currentMax, loadNextValueFromFile("file")); > return 0; >

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

2. Вопрос: Увеличивают ли шаблоны объём скомпилированного кода?

Ответ: Относительно эквивалентной логики без шаблонов - нет.

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

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

Сравнение ассемблерного кода для функции "max()"

Код без шаблонов:

int max(int a, int b) < return (a >= b ? a : b); > char max(char a, char b) < return (a >= b ? a : b); > // ------------------------------ int main() < // --- Пример для типа "int" --- int a = 1; int b = 2; int abMax = max(a, b); // --- Пример для типа "char" --- char aChar = 1; char bChar = 2; char abMaxChar = max(aChar, bChar); return 0; >

Код с шаблонами:

template Type maxTemplate(Type a, Type b) < return (a >= b ? a : b); > // ------------------------------ int main() < // --- Пример для типа "int" --- int a = 1; int b = 2; int abMax = maxTemplate(a, b); // --- Пример для типа "char" --- char aChar = 1; char bChar = 2; char abMaxChar = maxTemplate(aChar, bChar); return 0; >

Сравнение ассемблерного кода:

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

Сравнение ассемблерного кода для метода "Interval::intersection()"

class IntervalInt < public: IntervalInt(int inStart, int inEnd) : start(inStart), end(inEnd) < >int getStart() const < return start; >int getEnd() const < return end; >int getSize() const < return (end - start); >IntervalInt intersection(const IntervalInt& inOther) const < return IntervalInt< start >= inOther.start ? start : inOther.start, end ; > private: int start; int end; >; // ---------------------------------------------- class IntervalChar < public: IntervalChar(char inStart, char inEnd) : start(inStart), end(inEnd) < >char getStart() const < return start; >char getEnd() const < return end; >char getSize() const < return (end - start); >IntervalChar intersection(const IntervalChar& inOther) const < return IntervalChar< start >= inOther.start ? start : inOther.start, end ; > private: char start; char end; >;

Код с шаблонами

template class IntervalTemplate < public: IntervalTemplate(Type inStart, Type inEnd) : start(inStart), end(inEnd) < >Type getStart() const < return start; >Type getEnd() const < return end; >Type getSize() const < return (end - start); >IntervalTemplate intersection(const IntervalTemplate& inOther) const < return IntervalTemplate< start >= inOther.start ? start : inOther.start, end ; > private: Type start; Type end; >;

Сравнение ассемблерного кода:

3. Вопрос: Увеличивают ли шаблоны расход ресурсов на компиляцию кода?

Ответ: Да, но после перехода на C++20 ситуация может стать лучше.

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

Концепты из нового стандарта C++20 могут поменять ситуацию - по крайней мере, со временем выполнения компиляции. Они позволяют останавливать подстановку аргументов в шаблон до полноценного формирования шаблонного типа, и экономить таким образом время на завершение генерации априори некорректного типа.

4. Вопрос: Затрудняют ли шаблоны отладку кода?

Ответ: Поиск ошибок компиляции - затрудняют (однако с приходом концептов из C++20 станет лучше). Отладку ошибок в логике исполнения программы - нет.

Проблемы разбора ошибок компиляции были подробно описаны в пятом разделе.

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

Что такое шаблон?

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

В установку Joomla! автоматически добавлено несколько шаблонов. Вы можете найти много других шаблонов на разных сайтах или создать свой собственный в соответствии со стандартами Joomla! Некоторые доступны бесплатно в рамках различных лицензий, а некоторые можно купить. Кроме того, есть много дизайнеров, которые могут сделать пользовательские шаблоны. Вы также можете создать свой собственный шаблон.

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *