Variadic темплейты в C++, tuple / Variadic template and tuple

 Когда я решил разобраться с вариадик темплейтами, то, как обычно, пошел искать статьи на хабре и нашел их великое множество, но почти все они либо написаны так, как будто ты уже собаку съел на всех этих эллипсисах и тебе ничего не надо пояснять, либо не содержали нужной мне информации. Но вот наткнулся на эту статью, где все вроде бы понятно, рассмотрена концепция "откусывания головы" у переменного списка параметров (эллипсис), потом специализацию "дна", когда параметров уже не осталось и создается пустая структура (что есть конец шаблонной рекурсии) и аналогично, когда мы перечисляем все поля, реализован шаблон для нулевого поля ("стукаемся о дно структуры"). И для демонстрации всего этого рассмотрен пример реализации tuple. Но когда попробовал реализовать все это на VS2022, то выяснилось, что пример из хабра какой-то, мягко говоря, неоптимальный, когда на три поля (int, double, int) уходит 56 байт, а на обычную структуру уходит всего лишь 24 байта (это, кстати, при сумме размеров полей 16 байт, но тут уже выравнивание по 8 байтам уже работает на 64-битной архитектуре), что тоже не идеально, но уже гораздо лучше. Я собрал пример из статьи на хабре и получил вот такой отутпут:

12 2.34 89 12 2.34 89 12 2.34 89 sizeof(int) + sizeof(double) + sizeof(int) = 16 sizeof(habr_tuple<int, double, int>) = 56 sizeof(plain_struct) = 24

Вот пример с вариадиком с хабра:

1. template<typename... Args>
2. struct habr_tuple;
4. template<typename Head, typename... Tail>
5. struct habr_tuple<Head, Tail...> : habr_tuple<Tail...>
6. {
7. habr_tuple(Head h, Tail... tail)
8. : habr_tuple<Tail...>(tail...), head_(h)
9. {
10. }
11. typedef habr_tuple<Tail...> base_type;
12. typedef Head value_type;
14. base_type base = static_cast<base_type&>(*this);
15. Head head_;
16. };
18. template<>
19. struct habr_tuple<>
20. {
21. };
23. template<int I, typename Head, typename... Args>
24. struct getter
25. {
26. typedef typename getter<I - 1, Args...>::return_type return_type;
27. static return_type get(habr_tuple<Head, Args...> t)
28. {
29. return getter<I - 1, Args...>::get(t);
30. }
31. };
33. template<typename Head, typename... Args>
34. struct getter<0, Head, Args...>
35. {
36. typedef typename habr_tuple<Head, Args...>::value_type return_type;
37. static return_type get(habr_tuple<Head, Args...> t)
38. {
39. return t.head_;
40. }
41. };
43. template<int I, typename Head, typename... Args>
44. typename getter<I, Head, Args...>::return_type
45. get(habr_tuple<Head, Args...> t)
46. {
47. return getter<I, Head, Args...>::get(t);
48. };

Мне тут очень многое было непонятно, особенно член base, который ссылка (то есть по сути указатель, и по размеру тоже) - зачем он тут нужен? Почему нельзя было обойтись без него? А почему просто нельзя рекурсивно вставлять структуры, без указателей? Я переделал этот пример следующим образом:

1. template<typename... Args>
2. struct my_tuple;
4. // отделяем хвост от головы списка параметров
5. template<typename Head, typename... Tail>
6. struct my_tuple<Head, Tail...>
7. {
8. my_tuple(Head h, Tail... tail)
9. : head_(h), tail_(tail...)
10. {
11. }
12. typedef Head value_type;
14. Head head_;
15. my_tuple<Tail...> tail_;
16. };
18. // нет параметров - конец рекурсии (пустая структура)
19. template<>
20. struct my_tuple<>
21. {
22. };
24. // вспомогательная функция для получения поля по номеру
25. template<int I, typename Head, typename... Args>
26. struct getter2
27. {
28. typedef typename getter2<I - 1, Args...>::return_type return_type;
29. static return_type get(my_tuple<Head, Args...> t)
30. {
31. return getter2<I - 1, Args...>::get(t.tail_);
32. }
33. };
35. // вспомогательная функция, специализация для 0 (конец рекурсии)
36. template<typename Head, typename... Args>
37. struct getter2<0, Head, Args...>
38. {
39. typedef typename my_tuple<Head, Args...>::value_type return_type;
40. static return_type get(my_tuple<Head, Args...> t)
41. {
42. return t.head_;
43. }
44. };
46. // вспомогательная ф-я
47. template<int I, typename Head, typename... Args>
48. typename getter2<I, Head, Args...>::return_type
49. get(my_tuple<Head, Args...> t)
50. {
51. return getter2<I, Head, Args...>::get(t);
52. };

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

12 2.34 89 12 2.34 89 12 2.34 89 sizeof(int) + sizeof(double) + sizeof(int) = 16 sizeof(habr_tuple<int, double, int>) = 56 12 2.34 89 12 2.34 89 sizeof(my_tuple<int, double, int>) = 24 sizeof(std::tuple<int, double, int>) = 24 sizeof(plain_struct) = 24