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

Реализация универсального функтора-композитора

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

Необходимо написать универсальный функтор, применение операции вызова функции к которому приводило бы к выполнению такого кода:

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

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

Но есть некоторая сложность: если в списке передаваемых функций присутствуют несколько функций, типы которых совпадают, то код не скомпилируется, т. к. в списке базовых классов будет присутствовать один и тот же класс. Для устранения этой неоднозначности типы в пакете можно проиндексировать. Для этого будет использоваться вспомогательный тип «кортеж целых чисел», содержащий числа от 0 до заданного в качестве параметра N:

В итоге использовать этот шаблон можно следующим образом:

При этом Indexes будет эквивалентно:

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

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

Для определения типа возвращаемого значения используется другая новая для C++ конструкция — decltype. Результатом её применения (в данном случае) является тип возвращаемого функцией значения. Конструкция выглядит несколько странной. По смыслу она эквивалентна такой:

Но поскольку в области видимости класса пакет fs не определён, то оператор применяется к сконвертированному к ссылке на тип функции nullptr.

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

Осталось только определить функцию, облегчающую создание экземпляров этого класса:

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

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

Также этот класс можно было бы реализовать на базе кортежей из STL (std::tuple). В этом случае в классе DataHolder не было бы необходимости. С использованием std::tuple реализация композитора будет следующей:

Такой вариант выглядит несколько проще.

Ещё некоторое количество хитростей

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

То же в связке с constexpr:

Проверить, есть ли среди переданных чисел положительные — так:

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

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

К элементам пакета нельзя обращаться по индексу.

Источник

Шаблоны с многоточием и Variadic

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

Синтаксис

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

Ниже приведен простой пример синтаксиса определения класса шаблона Variadic :

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

Обратите внимание, что в этой статье используется соглашение, показанное в первом примере (многоточие присоединяется к typename ).

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

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

Ниже приведен простой пример синтаксиса функции шаблона Variadic :

Затем пакет параметров arguments разворачивается для использования, как показано в следующем разделе Общие сведения о шаблонах Variadic.

Возможны и другие формы синтаксиса шаблонной функции с переменным количеством аргументов возможны. Некоторые примеры приведены ниже.

const Также разрешены спецификаторы:

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

В шаблонах с переменным числом аргументов используется оператор sizeof. () (он не имеет отношения к старому оператору sizeof() ).

Дополнительные сведения о положении многоточия

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

В шаблоне-parameter-list ( template

) typename. представляет пакет параметров шаблона.

В предложении «параметр-объявление» ( func(parameter-list) ) многоточие «верхнего уровня» представляет пакет параметров функции, а расположение многоточия имеет важное значение:

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

Пример

Механизм действия шаблонных функций с переменным числом аргументов можно проиллюстрировать на показательном примере — переписать с ее использованием какую-либо функциональность printf :

Выходные данные

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

Источник

Шаблоны с переменным числом параметров

Кувшинов Д.Р.

Введение

Начиная с версии C++11 язык C++ предоставляет возможность определять шаблоны, принимающие переменное число параметров.

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

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

Итак, для определения шаблона с переменным числом параметров необходимо указать пакет типов в template-заголовке:

Возможны комбинации с обычными параметрами (как в примере с суммой), но допустим максимум один пакет. Пакет может быть пустым. Узнать размер пакета можно с помощью sizeof… (имя пакета).

Types можно использовать в списке параметров функции:

Теперь parameters — это пакет параметров, типы которых задаются “параллельным” пакетом Types. Пакет параметров может быть только в функции-шаблоне, и ему обязан соответствовать пакет типов.

Пример 1: суммирование целых чисел во время компиляции

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

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

Зачем сразу три определения?

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

является специализацией шаблона Sum для случая пустого пакета параметров. В этом случае мы определяем вложенную константу value со значением 0 (enum используется для краткости записи).

также является специализацией шаблона Sum, но теперь для случая наличия хотя бы одного параметра (first). Остальные параметры собираются в пакет other, который может быть пуст. Это определение позволяет собственно “запустить” рекурсивный процесс вычисления суммы. Рано или поздно other окажется пустым пакетом и будет подставлен нуль, определённый в предыдущей специализации.

Теперь представим, что требуется уметь вычислять суммарный размер произвольного набора типов — сумму значений sizeof для каждого типа. На основе Sum можно определить новый шаблон Sum_sizeof:

При использовании C++14 (шаблонов переменных) можно переписать весь код выше более кратко:

Пример 2: println

Определим две функции: print, выводящую подряд все свои параметры в cout, и println, переадресующую вызов print и затем печатающую символ перевода строки. Шаблоны функций в C++ нельзя специализировать частично (как классы), но можно перегружать. При вызове компилятор должен выбрать наиболее конкретный из подходящих вариантов.

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

Попробуем теперь обобщить данный код — разрешим указывать объект потока вывода первым параметром. Если он не указан, то выводить в cout.

Пример 3: format

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

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

даст “Intensity may take values between 0 and 1.” в случае выбора английского файла и “Насыщенность может принимать значения между 0 и 1.” в случае выбора русского файла. А

даст, соответственно “oil price forecasting” и “прогноз цены для нефти” (обратите внимание на возможность разного порядка подстановок).

Попробуем определить функцию format с помощью Стандартной библиотеки C++ и шаблонов с переменным числом параметров.

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

Теперь нет рекурсии, и нешаблонный вариант format уже не нужен. Мы инициализируем массив строк param строками, возвращаемыми для них функцией to_string. (Осторожно: to_string не принимает string! С этим разберёмся далее.). Пустая строка в начале позволяет гарантировать, что массив param будет содержать по крайней мере 1 элемент (массивы размера 0 запрещены).

Чтобы параметры-строки не вызывали ошибки компиляции, создадим свою вспомогательную функцию to_str и будем использовать её вместо to_string:

Реализовать format (собственно выполнение подстановки) можно по-разному. Например, “в лоб” на основе рукописного конечного автомата так:

Используя регулярные выражения ( #include ) из Стандартной библиотеки, можно записать похожий код более кратко:

Пример 4: список типов

Список типов type list — конструкция времени компиляции, задающая последовательность (“список”) произвольных типов и позволяющая оперировать этой последовательностью как единым целым.

Начнём с простейшего примера. Предположим, мы хотим подсчитать, сколько раз встречается заданный тип в пакете. Это можно сделать так (C++14):

Здесь, однако, нельзя говорить о списке типов Types, поскольку пакет параметров шаблона не является типом, и возможности его использования довольно ограничены. Впрочем, благодаря механизму частичной специализации шаблонов с подстановкой по образцу, легко связать пакет с конкретным типом. Для этого определим шаблон Type_list (который мог бы вовсе не иметь членов):

После этого следующий код выведет 0 2 :

Помимо подсчёта числа вхождений можно абсолютно аналогично через рекурсивное определение реализовать поиск первого вхождения (индекс):

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

В Стандартной библиотеке (в ) есть множество похожих определений, позволяющих выполнять ряд манипуляций с типами.

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

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

“Полноценной” метафункцией в синтаксисе C++ можно назвать нешаблонный класс, имеющий вложенное определение шаблона типа, которое уже можно использовать как t_at. Это позволяет передавать метафункцию как обычный тип.

Метафункцией высшего порядка называется метафункция, принимающая другие метафункции как аргументы.

Например, определим метафункцию добавления элемента в начало списка типов.

Недостаток этой конструкции очевиден: уж очень навороченно выглядит “вызов” метафункции:

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

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

Теперь можно записывать более сложные конструкции с меньшим синтаксическим шумом. Например, рекурсивное определение метафункции высшего порядка T_map, порождающей список результатов для заданной метафункции Map (“отображение”) и списка аргументов:

Можно ли T_map записать более кратко без рекурсии?

Определим ещё одну метафункцию высшего порядка — свёртку (fold). Пример свёрток: сумма элементов, произведение элементов, максимум, минимум и т.п. Аргументами свёртки являются ассоциативная бинарная операция и список.

В случае, если аргументы метафункции должны быть значениями, а не типами (наиболее типичные случаи: булевские и целочисленные константы), то их удобно “обернуть” в тип и представлять далее как типы. Например, для целочисленных констант можно было бы определить обёртку вроде

Впрочем, в Стандартной библиотеке уже есть аналогичный шаблон integral_constant, первый параметр которого — тип константы, второй — сама константа.

Определим функцию “максимум”, принимающую аргументы integral_constant:

Определим функцию T_sizeof, преобразующую тип в его размер (в виде соответствующего integral_constant).

Теперь мы можем найти максимальный размер типа из заданного списка:

Пример 5: Variant

В наследство от C языку C++ достался ряд низкоуровневых средств. Одним из таких средств является “объединение” (union) — набор значений, размещённых по одному адресу в памяти.

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

Позаимствуем часть кода из предыдущего примера (список типов).

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

Можно ли записать эти определения более кратко и без рекурсии?

Проверка “является ли список 1 подмножеством списка 2” (квадратичный рекурсивный алгоритм времени компиляции):

Вспомогательная конструкция: найти в списке типов первый тип (вернуть его номер), для которого определён конструктор, принимающий заданный набор параметров Args. Возвращает –1, если такого типа в списке нет:

Теперь есть достаточно вспомогательных определений, чтобы сделать простенькую версию вариантного типа. (Более продвинутый вариант, к тому же не требующий C++14, есть в пакете библиотек Boost, аналог планируется включить в Стандартную библиотеку C++17.)

Пакет Types (и отвечающий ему список типов types) содержит типы, значения которых могут хранится в объекте Variant. Потребуем, чтобы их было не меньше 0, но и не больше 63 (в принципе, текущая реализация допускает до 255 типов).

Память выделяется статически в виде некоего “объекта” (просто кусок памяти нужного размера с нужным выравниванием) _stor. Номер типа текущего значения хранится в поле _type. Для “неинициализированных” Variant это –1, т.е. никакого значения нет. Такие объекты Variant будем называть пустыми.

Теперь представим, что нам нужно уничтожить значение, хранящееся в Variant. Иными словами, надо вызвать деструктор для того типа, номер которого записан в поле _type. Это легко реализовать, если обернуть вызовы деструкторов для всех Types в функции с общим интерфейсом, указатели на которые можно просто сохранить в массиве и выбирать их, используя _type в качестве индекса.

Для инициализации/присваивания объектов Variant данный трюк несложно повторить. Чтобы не усложнять код, реализуем минимальный рабочий вариант на основе конструктора копирования.

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

Наконец, можно определить оператор присваивания одной специализации Variant значения другой специализации Variant. Для этого нам понадобится таблица перевода значений _type:

Удовлетворяет ли наш класс Variant правилу пяти?

При работе с подобными полиморфными объектами может быть удобно состыковать их с встроенными средствами C++ RTTI (run-time type information). В частности, можно реализовать извлечение результата typeid для хранимого в Variant значения. Это опять же можно сделать с помощью заранее созданной таблицы.

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

Источник

• ← шаблоны по умолчанию недопустимы исправьте шаблоны по умолчанию в диалоговом окне параметры
• шаговые двигатели таблица параметров →