Ответ 1
Кроме того, почему в первом объявлении шаблона + класса отсутствует "<S...>" сразу после объявления структуры? (Посмотрите, что закомментировано)? когда это правильно добавить, а когда нет?
Мне кажется, что лучше начать с этого момента.
Прежде всего, следующее (удалено с комментарием <S...>) является объявление (внимание: только объявление, а не определение) структуры шаблона. Example который получает список переменных типа шаблона.
template<typename... S>
struct Example;
Вы также можете избежать использования S и писать просто
template <typename...>
struct Example;
потому что имя списка переменных не используется в этом контексте.
На данный момент компилятор знает, что существует переменная шаблонная структура Example но не знает, как это делается.
Затем мы добавляем определение специализации Example которая получает один или несколько параметров шаблона (обратите внимание, что Example определена так, чтобы получить ноль или более параметров, поэтому специализация, которая получает один или несколько параметров, является частным случаем Example)
//....... one --> V VVVVV <- or more template parameter
template<typename H, typename... T>
struct Example<H, T...>
{ // .........^^^^^^^^^ <- this is a specialization
static const size_t value = sizeof(H) + Example<T...>::value;
};
Часть <H, T...> после Example идентифицирует специализацию (как сказано).
Эта специализация определить static const size_t переменная инициализирована с суммой sizeof(H) (The sizeof() первого параметра шаблона типа) с value, определенным в другом Example класса: Example<T...>.
Итак, вы наблюдаете рекурсивное определение: значение - это сумма sizeof() первого параметра (типа) с суммой sizeof() следующих типов.
Предложение: если вы используете шаблоны с переменными значениями, вы также можете использовать constexpr, поэтому лучше определить value как constexpr
static constexpr std::size_t value = sizeof(H) + Example<T...>::value;
Или, лучше, вы можете наследовать от std::integral_constant
template <typename H, typename... T>
struct Example <H, T...>
: public std::integral_constant<std::size_t, sizeof(H) + Example<T...>{}>
{ };
таким образом, вы наследуете value от std::integral_constant с дополнительными полезными средствами (например: автоматическое преобразование в std::size_t в контексте, где требуется std::size_t)
Каждая рекурсия нуждается в наземном обосновании, поэтому у вас есть
template<>
struct Example<>
{
static const size_t value = 0;
};
объявление другой специализации Example; на этот раз случай с точно нулевым параметром шаблона (Example<>). В этом случае у вас есть определение value, которая равна нулю для завершения рекурсии.
Как и раньше, вы можете определить value как constexpr или, лучше IMHO, снова используя std::integral_constant constexpr
template <>
struct Example<> : public std::integral_constant<std::size_t, 0u>
{ };
Теперь вы определили две специализации для Example: одну для случаев с одним или несколькими параметрами, одну для случая с нулевыми параметрами. Итак, вы рассмотрели все случаи для Example который объявлен получающим ноль или более параметров; нет необходимости объявлять универсальную (не специализированную версию) Example.
Как отмечает Deduplicator, вы можете определить общий случай и только одну специализацию: если вы пишете
template <typename...>
struct Example : public std::integral_constant<std::size_t, 0u>
{ };
template <typename T, typename ... Ts>
struct Example<T, Ts...>
: public std::integral_constant<std::size_t, sizeof(T)+Example<Ts...>{}>
{ };
Сначала вы объявляете Example получающий ноль или более параметров, и определяете общий случай со value ноль (основной случай), затем вы определяете одну или более специализацию.
Учитывая, что компилятор выбирает более специализированную версию (когда подходит больше версий), компилятор выбирает специализацию при наличии одного или нескольких параметров (версии ботов совпадают, но специализация более специализированная) и универсальную версию при нулевых параметрах (потому что специализация не совпадает).
Этот способ немного более синтетичен, но может быть менее понятным.
Не могли бы вы описать, что произойдет для звонка ниже? какой из шаблонов будет использоваться и когда?
Теперь должно быть просто понять.
Когда ты пишешь
Example<long, int, char>::value
вы запрашиваете value Example<long, int, char>.
Три параметра, так что выбирается одна или несколько специализаций, то есть
value = sizeof(long) + Example<int, char>::value;
по той же причине value в Example<int, char> равно
value = sizeof(int) + Example<char>::value;
и value в Example<char>
value = sizeof(char) + Example<>::value;
Теперь для Example<>::value выбрана специализация нулевых параметров, а Example<>::value равна нулю.
Итак, у нас есть value в Example<long, int, char> инициализируется
value = sizeof(long) + sizeof(int) + sizeof(char) + 0;
Вы пометили С++ 11, поэтому жаль, что вы не можете использовать С++ 17 (свертывание шаблонов), где вы можете вообще избежать рекурсии и определить Example как using
template <typename ... Ts>
using Example = std::integral_constant<std::size_t, (... + sizeof(Ts))>;