C++模板编程——typelist的实现

我爱普洱茶  金牌会员 | 2025-2-14 18:15:32 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 988|帖子 988|积分 2964

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
文章最后给出了汇总的代码，可直接运行
1. typelist是什么

typelist是一种用来操作类型的容器。和我们所熟知的vector、list、deque雷同，只不过typelist存储的不是变量，而是类型。
typelist简朴来说就是一个类型容器，可以或许提供一系列的操作。
本文将展示使用元编程实现typelist。
2. 要实现的typelist的接口

在此罗列一下即将要编写的typelist的所有接口：
   

  • typelist：要实现的容器类型。
  • front<typelist>：获取容器中的第一个元素。
  • size<typelist>：获取容器的元素数量。
  • pop_front<typelist, elem>：移出第一个元素。
  • push_front<typelist, elem>：向开头插入一个元素。
  • push_back<typelist, elem>：向末端插入一个元素。
  • replace_front<typelist, elem>：更换第一个元素。
  • is_empty<typelist>：判断是否为空。
  • find<typelist, index>：查找下标为index的元素。
  • get_maxsize_type<typelist>：容器中尺寸（sizeof）最大的元素。
  • reverse<typelist>：翻转容器中的元素。 
  • filter<typelist, Pre>:根据谓词Pre来过滤typelist中的类型。Pre应该是一个类模板，接受一个类型模板参数，并拥有一个bool类型的静态变量value，value为false时将该类型剔除typelist。
  3. 接口实现

3.1 容器

  1. template<typename... Elems>
  2. struct typelist{};
复制代码
3.2 front<typelist>

  1. template<typename TPLT>// typelist的简写
  2. struct front;
  4. struct front<typelist<FirstElem, OtherElems...>>
  5. {
  6.     using type = FirstElem;
  7. };
复制代码
3.3 size<typelist>

  1. template<typename TPLT>
  2. struct size;
  4. template<typename... Elems>
  5. struct size<typelist<Elems...>>
  6. {
  7.     static inline const value = sizeof...(Elems);
  8. };
复制代码
3.4 pop_front<typelist, elem>

  1. template<typename TPLT>
  2. struct pop_front;
  4. template<typename FirstElem, typename... OtherElems>
  5. struct pop_front<typelist<FirstElem, OtherElems...>
  6. {
  7.     using type = typelist<OtherrElems...>;
  8. };
复制代码
3.5 push_front<typelist, elem>

  1. template<typename TPLT, typename newElem>
  2. struct push_front;
  4. template<typename... Elems, typename newElem>
  5. struct push_front<typelist<Elems...>, newElem>
  6. {
  7.     using type = typelist<newElem, Elems...>;
  8. };
复制代码
3.6 push_back<typelist, elem>

  1. template<typename TPLT, typename newElem>
  2. struct push_back;
  4. template<typename... Elems, typename newElem>
  5. struct push_back<typelist<Elems...>, newElem>
  6. {
  7.     using type = typelist<Elems..., newElem>;
  8. };
复制代码
3.7 replace_front<TPLT, elem>

  1. template<typename TPLT, typename Elem>
  2. struct replace_front;
  4. template<typename FirstElem, typename... OtherElems, typename Elem>
  5. struct replace_front<typelist<FirstElem, OtherElems...>, Elem>
  6. {
  7.     using type = typelist<Elem, OtherElems...>;
  8. };
复制代码
3.8 is_empty<TPLT>

  1. template<typename TPLT>
  2. struct is_empty;
  4. template<typename... Elems>
  5. struct is_empty
  6. {
  7.     static inline const bool value = sizeof...(Elems) == 0;
  8. };
复制代码
3.9 find<typelist, index>

  1. template<typename TPLT, size_t index>
  2. struct find : find<typename pop_front<TPLT>::type, index - 1>
  3. {
  4.        
  5. };
  7. template<typename TPLT>
  8. struct find<TPLT, 0> :front<TPLT>
  9. {
  10. };
复制代码
3.10 get_maxsize_type<typelist>

  1. template<typename TPLT>
  2. struct get_maxsize_type
  3. {
  4. private:
  5.         using FirstType = typename front<TPLT>::type;
  6.         using RemainLT = typename pop_front<TPLT>::type;
  7.         using RemainMaxType = typename get_maxsize_type<RemainLT>::type;
  8. public:
  9.         using type = conditional_t < (sizeof(FirstType) > sizeof(RemainMaxType)),
  10.                 FirstType, RemainMaxType >;
  11. };
  13. template<typename Elem>
  14. struct get_maxsize_type<typelist<Elem>>
  15. {
  16.         using type = Elem;
  17. };
  19. template<>
  20. struct get_maxsize_type<typelist<>>;
复制代码
3.11 reverse<typelist>

  1. template<typename TPLT>
  2. struct reverse
  3. {
  4. private:
  5.         using FirstElem = typename front<TPLT>::type;
  6.         using RemainTL = typename pop_front<TPLT>::type;
  7.         using ReversedRemainTL = typename reverse<RemainTL>::type;
  8. public:
  9.         using type = typename push_back<ReversedRemainTL, FirstElem>::type;
  10. };
  13. template<>
  14. struct reverse<typelist<>>
  15. {
  16.         using type = typelist<>;
  17. };
复制代码
或
  1. template<typename TPLT, bool = is_empty<TPLT>::value>
  2. struct reverse;
  4. template<typename TPLT>
  5. struct reverse<TPLT, false>
  6. {
  7. private:
  8.         using FirstElem = typename front<TPLT>::type;
  9.         using RemainTL = typename pop_front<TPLT>::type;
  10.         using ReversedRemainTL = typename reverse<RemainTL>::type;
  11. public:
  12.         using type = typename push_back<ReversedRemainTL, FirstElem>::type;
  13. };
  15. template<typename TPLT>
  16. struct reverse<TPLT, true>
  17. {
  18.         using type = typelist<>;
  19. };
复制代码
3.12 filter<typelist, Pre>

  1. // 根据谓词过滤元素，谓词应该是一个类模板，接受一个类型参数，并且具有静态bool变量，false表示过滤掉该类型
  2. template<typename TPLT, template<typename>typename Pre>
  3. struct filter;
  5. template<typename FirstElem, typename... OtherElems, template<typename>typename Pre>
  6. struct filter<typelist<FirstElem, OtherElems...>, Pre>
  7. {
  8. private:
  9.         using RemainFilteredTL = typename filter<typelist<OtherElems...>, Pre>::type;
  10. public:
  11.         using type = std::conditional_t< Pre<FirstElem>::value,
  12.                 typename push_front<RemainFilteredTL, FirstElem>::type,
  13.                 RemainFilteredTL >;
  14. };
  16. template<template<typename>typename Pre>
  17. struct filter<typelist<>, Pre>
  18. {
  19.         using type = typelist<>;
  20. };
复制代码
  1. // 测试使用的类模板，用以剔除某个指定的类型
  2. template<typename InputType, typename FilterType = double>
  3. struct test_filter
  4. {
  5.         static constexpr bool value = !std::is_same_v<InputType, FilterType>;  //如果类型是int,就输出false,int不通过
  6. };
复制代码
 
4. 完备代码


  1. #include <iostream>
  2. #include <type_traits>
  3. #include "typegetter.hpp"
  5. using namespace std;
  7. /*
  9. */
  11. namespace myTypeList
  12. {
  13.         template<typename... Elems>
  14.         struct typelist {};
  16.         template<typename TPLT>
  17.         struct front;
  19.         template<typename FirstElem, typename... OtherElems>
  20.         struct front < typelist<FirstElem, OtherElems...>>
  21.         {
  22.                 using type = FirstElem;
  23.         };
  25.         template<typename TPLT>
  26.         struct size;
  28.         template<typename... Elems>
  29.         struct size<typelist<Elems...>>
  30.         {
  31.                 static const inline size_t value = sizeof...(Elems);
  32.         };
  34.         template<typename TPLT>
  35.         struct is_empty;
  37.         template<typename... Elems>
  38.         struct is_empty<typelist<Elems...>>
  39.         {
  40.                 static constexpr bool value = sizeof...(Elems) == 0;
  41.         };
  44.         template<typename TPLT>
  45.         struct pop_front;
  47.        
  48.         template<typename FirstElem, typename... OtherElems>
  49.         struct pop_front< typelist<FirstElem, OtherElems...> >
  50.         {
  51.                 using type = typelist<OtherElems...>;
  52.         };
  54.         template<typename TPLT, typename newElem>
  55.         struct push_front;
  57.         template<typename... Types, typename newElem>
  58.         struct push_front<typelist<Types...>, newElem>
  59.         {
  60.                 using type = typelist<newElem, Types...>;
  61.         };
  63.         template<typename TPLT, typename newElem>
  64.         struct push_back;
  66.         template<typename... Types, typename newElem>
  67.         struct push_back<typelist<Types...>, newElem>
  68.         {
  69.                 using type = typelist<Types..., newElem>;
  70.         };
  72.         template<typename TPLT, typename newElem>
  73.         struct replace_front;
  75.         template<typename FirstElem, typename... OtherElems, typename newElem>
  76.         struct replace_front<typelist<FirstElem, OtherElems...>, newElem>
  77.         {
  78.                 using type = typelist<newElem, OtherElems...>;
  79.         };
  81.        
  83.         template<typename TPLT, size_t index>
  84.         struct find : find<typename pop_front<TPLT>::type, index - 1>
  85.         {
  86.                
  87.         };
  89.         /*
  90.                 和下面的写法是等价的
  92.         template<typename TPLT, size_t index>
  93.         struct find
  94.         {
  95.                 using type = typename find<typename pop_front<TPLT>::type, index - 1>::type;
  96.         };
  98.         */
  100.         template<typename TPLT>
  101.         struct find<TPLT, 0> :front<TPLT>
  102.         {
  103.         };
  105.         /*
  106.                 get_maxsize_type: 获取typelist中尺寸最大的类型
  107.         */
  109.         template<typename TPLT>
  110.         struct get_maxsize_type
  111.         {
  112.         private:
  113.                 using FirstElem = typename front<TPLT>::type;
  114.                 using RemainLT = typename pop_front<TPLT>::type;
  115.                 using RemainMaxElem = typename get_maxsize_type<RemainLT>::type;
  116.         public:
  117.                 using type = conditional_t < (sizeof(FirstElem) > sizeof(RemainMaxElem)),
  118.                         FirstElem, RemainMaxElem >;
  119.         };
  121.         template<typename Elem>
  122.         struct get_maxsize_type<typelist<Elem>>
  123.         {
  124.                 using type = Elem;
  125.         };
  127.         template<>
  128.         struct get_maxsize_type<typelist<>>;
  131.         /*
  132.                 reverse: 翻转typelist
  133.         */
  134.         /*
  135.        
  136.         // 版本一
  138.         template<typename TPLT>
  139.         struct reverse
  140.         {
  141.         private:
  142.                 using FirstElem = typename front<TPLT>::type;
  143.                 using RemainTL = typename pop_front<TPLT>::type;
  144.                 using ReversedRemainTL = typename reverse<RemainTL>::type;
  145.         public:
  146.                 using type = typename push_back<ReversedRemainTL, FirstElem>::type;
  147.         };
  150.         template<>
  151.         struct reverse<typelist<>>
  152.         {
  153.                 using type = typelist<>;
  154.         };
  155.         */
  157.         template<typename TPLT, bool = is_empty<TPLT>::value>
  158.         struct reverse;
  160.         template<typename TPLT>
  161.         struct reverse<TPLT, false>
  162.         {
  163.         private:
  164.                 using FirstElem = typename front<TPLT>::type;
  165.                 using RemainTL = typename pop_front<TPLT>::type;
  166.                 using ReversedRemainTL = typename reverse<RemainTL>::type;
  167.         public:
  168.                 using type = typename push_back<ReversedRemainTL, FirstElem>::type;
  169.         };
  171.         template<typename TPLT>
  172.         struct reverse<TPLT, true>
  173.         {
  174.                 using type = typelist<>;
  175.         };
  177.         // 根据谓词过滤元素，谓词应该是一个类模板，接受一个类型参数，并且具有静态bool变量，false表示过滤掉该类型
  178.         template<typename TPLT, template<typename>typename Pre>
  179.         struct filter;
  181.         template<typename FirstElem, typename... OtherElems, template<typename>typename Pre>
  182.         struct filter<typelist<FirstElem, OtherElems...>, Pre>
  183.         {
  184.         private:
  185.                 using RemainFilteredTL = typename filter<typelist<OtherElems...>, Pre>::type;
  186.         public:
  187.                 using type = std::conditional_t< Pre<FirstElem>::value,
  188.                         typename push_front<RemainFilteredTL, FirstElem>::type,
  189.                         RemainFilteredTL >;
  190.         };
  192.         template<template<typename>typename Pre>
  193.         struct filter<typelist<>, Pre>
  194.         {
  195.                 using type = typelist<>;
  196.         };
  197. }
  199. class A {};
  202. // 测试使用的类模板，用以剔除某个指定的类型
  203. template<typename InputType, typename FilterType = double>
  204. struct test_filter
  205. {
  206.         static constexpr bool value = !is_same_v<InputType, FilterType>;  //如果类型是int,就输出false,int不通过
  207. };
  209. int main()
  210. {
  211.         using TPL_1 = myTypeList::typelist<char, short, char, int, double, int, long, A, double>;
  212.         using TPL_2 = myTypeList::typelist<>;
  214.         cout << "----------------------------------" << endl;
  215.         cout << "TPLT_1 为：" << TypeGetter<TPL_1>::name << endl;
  216.         cout << "TPLT_2 为：" << TypeGetter<TPL_2>::name << endl;
  217.         cout << "----------------------------------" << endl;
  219.         cout << "TPL_1 的第一个类型为" << TypeGetter< myTypeList::front<TPL_1>::type >::name << endl;
  220.         //cout << "TPL_2 的第一个类型为" << TypeGetter< myTypeList::front<TPL_2>::type >::name << endl;
  222.         cout << "TPL_1 的size为：" << myTypeList::size<TPL_1>::value << endl;
  223.         cout << "TPL_2 的size为：" << myTypeList::size<TPL_2>::value << endl;
  225.         cout << "TPL_1 的pop_front为：" << TypeGetter< myTypeList::pop_front< TPL_1 >::type >::name << endl;
  226.         //cout << "TPL_2 的pop_front为：" << TypeGetter< myTypeList::pop_front< TPL_2 >::type >::name << endl;
  228.         cout << "TPL_1 push_front bool 为：" << TypeGetter< myTypeList::push_front<TPL_1, bool>::type>::name << endl;
  229.         cout << "TPL_2 push_front bool 为：" << TypeGetter< myTypeList::push_front<TPL_2, bool>::type>::name << endl;
  231.         cout << "TPL_1 push_back bool 为：" << TypeGetter< myTypeList::push_back<TPL_1, bool>::type>::name << endl;
  232.         cout << "TPL_2 push_back bool 为：" << TypeGetter< myTypeList::push_back<TPL_2, bool>::type>::name << endl;
  234.         cout << "TPL_1 replace_front with char 为：" << TypeGetter < myTypeList::replace_front< TPL_1, char >::type>::name << endl;
  236.         cout << "TPL_1 index 2 type 为：" << TypeGetter< myTypeList::find<TPL_1, 2>::type > ::name << endl;
  238.         cout << "TPL_1 max size type 为：" << TypeGetter<myTypeList::get_maxsize_type<TPL_1>::type>::name << endl;
  240.         cout << "TPL_1         为：" << TypeGetter<TPL_1>::name << endl;
  241.         cout << "TPL_1 reverse 为：" << TypeGetter<myTypeList::reverse<TPL_1>::type>::name << endl;
  243.         cout << "TPL_1 经过int_filter过滤为：" << TypeGetter<myTypeList::filter<TPL_1, test_filter>::type>::name << endl;
  244.         cout << "TPL_2 经过int_filter过滤为：" << TypeGetter<myTypeList::filter<TPL_2, test_filter>::type>::name << endl;
  245.         return 0;
  246. }
复制代码
typegetter.hpp的代码如下所示：
  1. #pragma once
  3. #include <string>
  4. #include "boost/type_index.hpp"
  7. template<typename T>
  8. class TypeGetter
  9. {
  10. public:
  11.         static inline const std::string name = boost::typeindex::type_id_with_cvr<T>().pretty_name();
  12. };
复制代码

 运行结果如下： 



免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

我爱普洱茶

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表