Нужны коментарии к программе. Вывод типов переданных аргументов

#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);
}

// Послушайте!
#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);
    // над крышами
    // загоралась хоть одна звезда?!
}

#include <iostream>
 
// объявляем шаблон пустой структуры
template <typename T>
struct NameOf {};
 
// объявляем макрос для генерации специализации шаблона
// где для каждой специализации добавляется статической свойство value
// хранящее название типа для специализации
#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);
}