Что означают данные строки?

Question

[Евгений Крамор]

#include <iostream>

template <typename T>
struct NameOf {};

#define DEF_TYPENAME(type) template <> \
struct NameOf<type> {\
    static const char value[];\
};\
const char NameOf<type>::value[] = #type;

DEF_TYPENAME(int)
DEF_TYPENAME(double)
DEF_TYPENAME(long double)
DEF_TYPENAME(float)
DEF_TYPENAME(char)
DEF_TYPENAME(long)
DEF_TYPENAME(unsigned)
DEF_TYPENAME(unsigned long)

template <typename T, typename ...types>
void printTypes(T)
{
    std::cout << NameOf<T>::value << std::endl;
}

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

int main(int argc, char *argv[])
{
    printTypes(1,2U,3L, 4.0, 5.0L, 6UL, 'a', 8.0F);
}

Никак не могу понять, что в этом коде означают вот эти блоки?
Первый блок:

DEF_TYPENAME(int)
DEF_TYPENAME(double)
DEF_TYPENAME(long double)
DEF_TYPENAME(float)
DEF_TYPENAME(char)
DEF_TYPENAME(long)
DEF_TYPENAME(unsigned)
DEF_TYPENAME(unsigned long)

Второй блок (тут непонятно использование троеточия):

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

Comments

[Евгений Шатунов]

Евгений Крамор , твой пример кода не полный. Из него невозможно определить контекст выражения.
Приведи полный код определения выражения.

DEF_TYPE - судя по стилю это макрос препроцессора. Во что этот макрос раскрывается - известно только тебе, т.к. только у тебя есть все изучаемые тобой тексты.

[Евгений Крамор]

Евгений Шатунов,

#include <iostream>

template <typename T>
struct NameOf {};

#define DEF_TYPENAME(type) template <> \
struct NameOf<type> {\
    static const char value[];\
};\
const char NameOf<type>::value[] = #type;

DEF_TYPENAME(int)
DEF_TYPENAME(double)
DEF_TYPENAME(long double)
DEF_TYPENAME(float)
DEF_TYPENAME(char)
DEF_TYPENAME(long)
DEF_TYPENAME(unsigned)
DEF_TYPENAME(unsigned long)

template <typename T, typename ...types>
void printTypes(T)
{
    std::cout << NameOf<T>::value << std::endl;
}

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

int main(int argc, char *argv[])
{
    printTypes(1,2U,3L, 4.0, 5.0L, 6UL, 'a', 8.0F);
}

Вот полный код.

Мне нужно понять, что из этого вариативного шаблона

void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

означает буква t

Answer 1

[Mercury13]

Перед нами вариативный шаблон Си++11.

Функция printTypes действует так. Для первого параметра подбираем подходящую перегрузку функции NameOf. Второй и далее — снова подставляем в функцию printTypes.

types... t — это любое количество параметров любых типов. Которые, в свою очередь, можно рекурсивно подставить в шаблон printTypes.

DEF_TYPENAME(float) — это использование препроцессора Си++ (никакой уже не 11), чтобы объявить несколько стандартных специализаций одного шаблона.

Comments

[Евгений Шатунов]

Поправлю: NameOf - это шаблон типа.

[Евгений Крамор]

Я уже разобрался с именем параметров, сейчас хочу разобраться со строкой DEF_TYPENAME(float). Не полностью могу "вникнуть" в неё.

Answer 2

[Евгений Шатунов]

Давай разбирать код по порядку.

template <typename T>
struct NameOf {};

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

#define DEF_TYPENAME(type) template <> \
struct NameOf<type> {\
    static const char value[];\
};\
const char NameOf<type>::value[] = #type;

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

DEF_TYPENAME(int)
DEF_TYPENAME(double)
DEF_TYPENAME(long double)
DEF_TYPENAME(float)
DEF_TYPENAME(char)
DEF_TYPENAME(long)
DEF_TYPENAME(unsigned)
DEF_TYPENAME(unsigned long)

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

template <typename T, typename ...types>
void printTypes(T)
{
    std::cout << NameOf<T>::value << std::endl;
}

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

В этом месте определено два шаблона функции с перегрузкой. Первый шаблон - от одного аргумента, второй - от переменного числа параметров шаблона. Такое определение дает две ветви вывода функции printTypes из шаблона. Я сейчас остановлюсь лишь на второй ветви вывода.

template <typename T, typename ...types>
void printTypes(T, types... t)
{
    std::cout << NameOf<T>::value << ", ";
    printTypes(t...);
}

Это - шаблон функции с переменным числом параметров шаблона (Variadic template). Синтаксис typename ...types в объявлении шаблона говорит что типов ожидается от нуля и пока фантазия не кончится. Как пользоваться таким шаблонами - хорошо описано в документации по моей ссылке.
Суть же этой ветви вывода заключается в том, чтобы позволить пользователю вызывать функцию с произвольным набором аргументов. В своем теле функция работает как будто ее вызвали от одного (первого) аргумента и далее рекурсивно уходит в вызов только от хвоста оставшегося списка аргументов.

В следствии оптимизации, хвостовая рекурсия развернется в плоскую последовательность обращений к std::cout << NameOf<T>::value << std::endl;.

Comments

[Евгений Крамор]

Спасибо большое! Ещё один момент: строка DEF_TYPENAME(float).
Как я понял, когда препроцессор видит данную строку, он её заменяет на:

template <> \
struct NameOf<type> {\
    static const char value[];\
};\
const char NameOf<type>::value[] = #type;

И получается в результате вызова DEF_TYPENAME(float) мы специализируем структуру NameOf в статическую переменную NameOf::value запишем строчку "float"?

[Roman]

Евгений Крамор, https://gcc.godbolt.org/z/Tg_c0S
строка 22038

[Евгений Шатунов]

Евгений Крамор, После препроцессора в месте DEF_TYPENAME(float) будет такой код:

template<>
struct NameOf<float> {
    static const char value[];
};
const char NameOf<type>::value[] = "float";

Шаблон NameOf всегда представляет из себя тип. У этого типа всегда будет статическая константа - строка с инициализацией от строкового литерала с именем типа из макроса.

При чем, данная запись также очень неоптимальна с точки зрения компиляции. В этом месте уже сформирован и доступен строковой литерал, но пользователь пишет инициализировать им массив-строку. Инициализация делает ненужным сам строковой литерал, но теперь надо снова размещать статический массив-строку. Пуллинг строк в этом месте компиляцию также не ускоряет, т.к. нужно найти размещение строкового литерела и перенести размещение массива-строки в это место.
Тут должна быть запись static constexpr const char* value = "float"; прямо внутри определения типа NameOf. Это будет тривиальный статик, которому не требуется размещение, в котором лишь на время компиляции будет храниться указатель на уже размещенный строковой литерал.