AUX778076_SEQUENCE_NAME(假设为boost::mpl::vector)模拟编译器的推导过程

最新推荐文章于 2024-07-27 07:00:00 发布
原创 最新推荐文章于 2024-07-27 07:00:00 发布 · 1.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#vector #编译器 #struct #wrapper #c #gcc

本文介绍Boost.MPL库中向量模板的实现细节，包括宏定义、模板特化及偏特化等高级C++元编程技术的应用。通过复杂的宏定义实现了向量类型的动态创建与模板参数的处理。 
#   define BOOST_MPL_LIMIT_VECTOR_SIZE 20
#   define AUX778076_SEQUENCE_NAME vector
#   define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE
namespace boost { namespace mpl {
#if !defined(AUX778076_SEQUENCE_BASE_NAME)
#   define AUX778076_SEQUENCE_BASE_NAME AUX778076_SEQUENCE_NAME
// AUX778076_SEQUENCE_BASE_NAME  vector
#endif
#if !defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER)
#   define AUX778076_SEQUENCE_PARAM_NAME T
#   define AUX778076_SEQUENCE_TEMPLATE_PARAM typename T
#   define AUX778076_SEQUENCE_DEFAULT na
    //BOOST_PP_CAT 起连接作用，如果传入的参数为0,1,2
    //展开后的形式为： vector0, vecotr1, vector2
#   define AUX778076_SEQUENCE_NAME_N(n) /
    BOOST_PP_CAT(AUX778076_SEQUENCE_BASE_NAME,n) /
    /**/
//下面这项展开的形式为：
// typename T0, typename T1, typename T2, typename T3 ...... typename T19 共20项
#   define AUX778076_SEQUENCE_PARAMS() /
    BOOST_PP_ENUM_PARAMS( /
    AUX778076_SEQUENCE_LIMIT /
    , AUX778076_SEQUENCE_TEMPLATE_PARAM /
    ) /
    /**/
//展开的形式为：
//T0, T1, T2, T3 ...... T19 共20项
#   define AUX778076_SEQUENCE_ARGS() /
    BOOST_PP_ENUM_PARAMS( /
    AUX778076_SEQUENCE_LIMIT /
    , T /
    ) /
    /**/
//展开的形式： AUX778076_SEQUENCE_DEFAULT 为 na ,na代表类型，起标识作用。
//typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
//typename T4 = na, typename T5 = na ...... typename T19 = na
#   define AUX778076_SEQUENCE_DEFAULT_PARAMS() /
    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( /
    AUX778076_SEQUENCE_LIMIT /
    , AUX778076_SEQUENCE_TEMPLATE_PARAM /
    , AUX778076_SEQUENCE_DEFAULT /
    ) /
    /**/
//这是一个指定的展开形式：假如传入的参数为3，则展开形式：
//typename T0, typename T1, typename T2
#   define AUX778076_SEQUENCE_N_PARAMS(n) /
    BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) /
    /**/
//展开的形式为：
//T0,  T1, T2 ... Tn
#   define AUX778076_SEQUENCE_N_ARGS(n) /
    BOOST_PP_ENUM_PARAMS(n, T) /
    /**/
//# define BOOST_PP_TUPLE_ELEM_3_2(a, b, c) c
//BOOST_PP_ENUM(18, BOOST_PP_TUPLE_ELEM_3_2, na)
//
#   define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) /
    BOOST_PP_ENUM_PARAMS(n, T) /
    BOOST_PP_COMMA_IF(n) /
    BOOST_PP_ENUM( /
    BOOST_PP_SUB_D(1,AUX778076_SEQUENCE_LIMIT,n) /
    , BOOST_PP_TUPLE_ELEM_3_2 /
    , AUX778076_SEQUENCE_DEFAULT /
    ) /
    /**/
#else // AUX778076_SEQUENCE_INTEGRAL_WRAPPER
#   define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/
#   define AUX778076_SEQUENCE_PARAM_NAME C
#   define AUX778076_SEQUENCE_TEMPLATE_PARAM BOOST_MPL_AUX_NTTP_DECL(long, C)
#   define AUX778076_SEQUENCE_DEFAULT LONG_MAX
// typename T, long C0, longC1 ...... long C19
#   define AUX778076_SEQUENCE_PARAMS() /
    typename T, BOOST_PP_ENUM_PARAMS( /
    AUX778076_SEQUENCE_LIMIT /
    , AUX778076_SEQUENCE_TEMPLATE_PARAM /
    ) /
    /**/
// T, C0, C1, C2 ...... C19
#   define AUX778076_SEQUENCE_ARGS() /
    T, BOOST_PP_ENUM_PARAMS( /
    AUX778076_SEQUENCE_LIMIT /
    , C /
    ) /
    /**/
// typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX ...... long C19 = LONG_MAX
#   define AUX778076_SEQUENCE_DEFAULT_PARAMS() /
    typename T, /
    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( /
    AUX778076_SEQUENCE_LIMIT /
    , AUX778076_SEQUENCE_TEMPLATE_PARAM /
    , AUX778076_SEQUENCE_DEFAULT /
    ) /
    /**/
// typename T, long C0, long C1, long C2, ...... long Cn
#   define AUX778076_SEQUENCE_N_PARAMS(n) /
    typename T BOOST_PP_COMMA_IF(n) /
    BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) /
    /**/
#   if !defined(AUX778076_SEQUENCE_CONVERT_CN_TO)
#       define AUX778076_SEQUENCE_CONVERT_CN_TO(z,n,TARGET) BOOST_PP_CAT(C,n)
#   endif
// T, n, Cn, T
#   define AUX778076_SEQUENCE_N_ARGS(n) /
    T BOOST_PP_COMMA_IF(n) /
    BOOST_PP_ENUM(n,AUX778076_SEQUENCE_CONVERT_CN_TO,T) /
    /**/
#   define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) /
    T, BOOST_PP_ENUM_PARAMS(n, C) /
    BOOST_PP_COMMA_IF(n) /
    BOOST_PP_ENUM( /
    BOOST_PP_SUB_D(1,AUX778076_SEQUENCE_LIMIT,n) /
    , BOOST_PP_TUPLE_ELEM_3_2 /
    , AUX778076_SEQUENCE_DEFAULT /
    ) /
    /**/
#endif // AUX778076_SEQUENCE_INTEGRAL_WRAPPER
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    // forward declaration
    //一个推导的形式为：
    //template<typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na... typename T19 = na>
    //struct vector;
    template<
        AUX778076_SEQUENCE_DEFAULT_PARAMS()
    >
    struct AUX778076_SEQUENCE_NAME;
#else
   // template <int N>
   // struct vector_chooser;
    namespace aux {
        template< BOOST_MPL_AUX_NTTP_DECL(int, N) >
        struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser);
    }
#endif
#define BOOST_PP_ITERATION_PARAMS_1 /
    (3,(0, AUX778076_SEQUENCE_LIMIT, <boost/mpl/aux_/sequence_wrapper.hpp>))
#include BOOST_PP_ITERATE()
    // real C++ version is already taken care of
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
    namespace aux {
        // ???_count_args
#define AUX778076_COUNT_ARGS_PREFIX         AUX778076_SEQUENCE_NAME
#define AUX778076_COUNT_ARGS_DEFAULT        AUX778076_SEQUENCE_DEFAULT
#define AUX778076_COUNT_ARGS_PARAM_NAME     AUX778076_SEQUENCE_PARAM_NAME
#define AUX778076_COUNT_ARGS_TEMPLATE_PARAM AUX778076_SEQUENCE_TEMPLATE_PARAM
#define AUX778076_COUNT_ARGS_ARITY          AUX778076_SEQUENCE_LIMIT
#define AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES
#include <boost/mpl/aux_/count_args.hpp>
//template <typename T0, typename T1, typename T2, typename T3 ...... typename T19 >
//struct  vector_impl
//{
// vector_count_args<T0, T1, T2, ...... T19> arg_num_;
// typedef typename vector_chooser<arg_num_::vaule>
//     ::template result<T0, T1, T2, T3 ...... T19>::type type;
//};
        template<
            AUX778076_SEQUENCE_PARAMS()
        >
        struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)
        {
            typedef aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_count_args)<
                BOOST_PP_ENUM_PARAMS(AUX778076_SEQUENCE_LIMIT, AUX778076_SEQUENCE_PARAM_NAME)
            > arg_num_;
            typedef typename aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser)< arg_num_::value >
                ::template result_< AUX778076_SEQUENCE_ARGS() >::type type;
        };
    } // namespace aux
// template<typename T0, typename T1, typename T2, typename T3 ...... typename T19>
// struct vector : vector_impl<T0, T1, T2, T3 ...... T19>::type
//{
//   typedef  typename  vector_impl<T0, T1, T2, T3 ...... T19>::type type;
//
//};
    template<
        AUX778076_SEQUENCE_DEFAULT_PARAMS()
    >
    struct AUX778076_SEQUENCE_NAME
        : aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)<
        AUX778076_SEQUENCE_ARGS()
        >::type
    {
        typedef typename aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)<
            AUX778076_SEQUENCE_ARGS()
        >::type type;
    };
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#   undef AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS
#   undef AUX778076_SEQUENCE_N_ARGS
#   undef AUX778076_SEQUENCE_CONVERT_CN_TO
#   undef AUX778076_SEQUENCE_N_PARAMS
#   undef AUX778076_SEQUENCE_DEFAULT_PARAMS
#   undef AUX778076_SEQUENCE_ARGS
#   undef AUX778076_SEQUENCE_PARAMS
#   undef AUX778076_SEQUENCE_NAME_N
#   undef AUX778076_SEQUENCE_DEFAULT
#   undef AUX778076_SEQUENCE_TEMPLATE_PARAM
#   undef AUX778076_SEQUENCE_PARAM_NAME
#   undef AUX778076_SEQUENCE_LIMIT
#   undef AUX778076_SEQUENCE_BASE_NAME
#   undef AUX778076_SEQUENCE_NAME
#   undef AUX778076_SEQUENCE_INTEGRAL_WRAPPER
}}
///// iteration
#else
#define i_ BOOST_PP_FRAME_ITERATION(1)
#   if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
#if i_ == AUX778076_SEQUENCE_LIMIT
/// primary template (not a specialization!)
//宏仅仅是展开，并不会进行模板特化。 假设传入的参数为： N
// template <typename T0, typename T1, typename T2, typename T3 , ... , typename TN>
// struct vector : vectorN<T0,T1,T2,T3,...,TN>
// {
//   typedef typename vectorN<T0,T1,T2,T3,...,TN>::type type;
//  
// };
template<
AUX778076_SEQUENCE_N_PARAMS(i_)
>
struct AUX778076_SEQUENCE_NAME
    : AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >
{
    typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type;
};
#else
//template<typename T0, typename T1, typename T2, typename T3 , ... , typename TN>
//struct vector<T0,T1,T2,T3,...,TN>: vectorN<T0,T1,T2,T3,...,TN>
//#if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER)
//   typedef typename vectorN<T0,T1,T2,T3,...,TN>::type type;
//#else
//   typedef vectorN<T0,T1,T2,T3,...,TN>::type type;
//#endif
//};
template<
AUX778076_SEQUENCE_N_PARAMS(i_)
>
struct AUX778076_SEQUENCE_NAME< AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(i_) >
    : AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >
{
#if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER)
    typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type;
#else
    typedef AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type;
#endif
};
#endif // i_ == AUX778076_SEQUENCE_LIMIT
#   else
namespace aux {
// template<>
// struct vector_chooser<i>
// { 
//    template <typename T0, typename T1, typename T2, typename T3 ...... typename T19>
//    struct result_
//    { 
//  #if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER)
//      typedef typename vectori_<T0,T1,...,Ti_>::type type;
//  #else
//        typedef vectori_<T0,T1,...,Ti>::type type;
//  #endif
//    };
//};
    struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser)<i_>
    {
        template<
            AUX778076_SEQUENCE_PARAMS()
        >
        struct result_
        {
#if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER)
            typedef typename AUX778076_SEQUENCE_NAME_N(i_)<
                AUX778076_SEQUENCE_N_ARGS(i_)
            >::type type;
#else
            typedef AUX778076_SEQUENCE_NAME_N(i_)<
                AUX778076_SEQUENCE_N_ARGS(i_)
            >::type type;
#endif
        };
    };
} // namespace aux
#   endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#undef i_
#endif // BOOST_PP_IS_ITERATING

 

boost::mpl::aux::msvc_is_class相关用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-13 294
boost::mpl::aux::msvc_is_class相关用法的测试程序实现功能C++实现代码 实现功能 boost::mpl::aux::msvc_is_class相关用法的测试程序 C++实现代码 #include <boost/mpl/aux_/config/msvc.hpp> #include <boost/mpl/aux_/config/workaround.hpp> #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) #incl
C++元编程：使用 boost::mpl::size 实现序列长度计算
TechInk的博客
08-22 123
然后，我们使用 boost::mpl::size 模板类来计算 my_list 的长度，并将结果存储在一个名为 size 的常量中。需要注意的是，由于 boost::mpl::size 算法是在编译期完成计算的，因此我们需要使用 constexpr 关键字来定义变量 size。boost::mpl::size 算法的作用是计算一个序列的长度，其实现非常简单，只需要在 boost/mpl/size.hpp 中引入相应的头文件即可。C++元编程：使用 boost::mpl::size 实现序列长度计算。
C++元编程和Boost编程库 （C++ Metaprogramming and Boost MPL ）中部
hityct1的专栏
05-16 1万+
Boost中的MPL库分析      MPL（Meta-Programming Library）是由David Abrahams和Aleksey Gurtovoy为方便模板元编程而开发的库，2003年被Boost吸纳为其中的一员，此后又历经一些大幅度修改，目前已经相当完善，其最新版本于2004年11月发布。MPL的出现是C++模板元编程发展中的一大创举，它提供了一个通用、高层次
使用boost::mpl实现list相关的测试程序
PixelDude的博客
08-29 217
boost::mpl是一个流行的C++元编程库，它提供了许多元编程工具和算法。其中，mpl::list是boost::mpl库中一个非常有用的组件，它是一个类型列表容器，可以用于存储不同类型的元素。除此之外，boost::mpl还提供了许多其它有用的元编程工具，例如条件、循环、递归等。接着，我们可以使用mpl::at获取list中指定位置的元素，并通过mpl::size获取list的大小。本文仅是一个简单的介绍，读者可根据自己的需求进一步探究boost::mpl库的更多用法和技巧。
C++ Meta Programming 和 Boost MPL(4)
kimi's Blog
08-30 1521
本系列全部转载自kuibyshev.bokee.com1.  Boost中的MPL库分析MPL是由David Abrahams和Aleksey Gurtovoy为方便模板元编程而开发的库，2003年被Boost吸纳为其中的一员，此后又历经一些大幅度修改，目前已经相当完善，其最新版本于2004年11月发布。MPL的出现是C++模板元编程发展中的一大创举，它提供了一个通用、高层次的编程
boost::mpl::vector(GCC)源码分析
yshuise的专栏
06-06 4090
//GCC支持关键字typeof,MSVC不支持。所以boost::mpl::vector GCC 版本的便是基于类型的识别。 //在使用typeof关键字时，如果是求函数的返回类型，这个函数实际上无需定义，只需要声明即可。 //下面可以看到：这个版本的vector使用函数重载来标记不同的vector参数，比如：vector<int,double> //第0位就是int。实现的方式就...
ImportError: cannot import name ‘MultiModalData‘ from ‘vllm.sequence‘解决方案
热门推荐
weixin_43178406的博客
07-27 10万+
 本文主要介绍了ImportError: cannot import name ‘MultiModalData’ from 'vllm.sequence’解决方案，希望能对使用Python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
boost log库链接问题
wxf306989618的博客
05-27 3329
1. 使用动态库时，要定义BOOST_LOG_DYN_LINK或者BOOST_ALL_DYN_LINK 否则会出现如下错误： CMakeFiles/IrcChatData.dir/src/main.cpp.o: In function `boost::log::v2s_mt_posix::sources::basic_logger<char, boost::log::v2s_m...
vs2015 64位下boost log 无法链接
CandyPz
11-07 2680
vs2015 64位下boost log 无法链接错误信息1>main.obj : error LNK2019: 无法解析的外部符号 "private: static unsigned int __cdecl boost::log::v2s_mt_nt5::attribute_name::get_id_from_string(char const *)" (?get_id_from_string@a
boost::mpl::list 源码分析
yshuise的专栏
06-20 5316
使用 list 的方法如下： #include <iostream> #include <boost/mpl/list/list10.hpp> #include <boost/mpl/size.hpp> using namespace boost; using namespace std; int _tmain(int argc, _TCHAR* argv[...
Boost程序库探秘 深度解析C++准标准库(501-550) (第二版)
06-23
Boost程序库探秘 深度解析C++准标准库(501-550) (第二版)，只有我这里有全套的，赶紧来下载吧！ (501-550)指页数
boost::mpl::vector用法的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-10 538
boost::mpl::vector用法的测试程序实现功能C++实现代码 实现功能 boost::mpl::vector用法的测试程序 C++实现代码 #include <boost/hana/equal.hpp> #include <boost/hana/front.hpp> #include <boost/hana/integral_constant.hpp> #include <boost/hana/type.hpp> #include <boos
【模式识别】MPL,MIL和MCL
weixin_30734435的博客
04-17 308
Multi-Instance Learning (MIL) 和Multi-Pose Learning (MPL)是CV的大牛Boris Babenko at UC San Diego提出来的。其思想能够用以下一幅图概况。MIL是指一个对象的学习实例可能有非常多种情况，学习的时候不是用一个精确...
boost::mpl操作类型向量
zhuge19870104的博客
04-22 696
代码比较简单，直接上代码了。 CMakeLists.txt cmake_minimum_required(VERSION 2.6) project(splitting_tuple) add_definitions(-std=c++14) include_directories("/usr/local/include") link_directories("/usr/local/lib") file( GLOB APP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
C 和 C++ 编程中的整数溢出
liufangren1982的专栏
09-11 4420
 一、 超越整数范围的溢出当执行算法以计算缓冲区大小，真正的安全性漏洞会随同这些缺陷一起出现。请看下面的示例： void func(char *b1, int c1, char *b2, int c2) {    const int MAX = 48;    if (c1 + c2 > MAX) return;    char *pBuff = new char[MAX];
boost::mpl::size相关的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-13 315
boost::mpl::size相关的测试程序实现功能C++实现代码 实现功能 boost::mpl::size相关的测试程序 C++实现代码 #include <boost/mpl/size.hpp> #include <boost/mpl/list.hpp> #include <boost/mpl/aux_/test.hpp> MPL_TEST_CASE() { typedef list<> empty_list; typedef list
C++元编程和Boost编程库 （C++ Metaprogramming and Boost MPL ）
痞子龙3D编程
05-05 2944
引论      C++的发展史是一个不断吸收程序设计领域精华和不断积累充实语言特性的过程。它的创造者Stroustrup在这门新的编程语言草创之初就定下了几个基本的目标，二十年过去了，至今这些目标仍然是C++继续发展的指南针。其中他明确指出，这种语言不应强迫程序员使用单一程序设计形式[20]；就是说C++语言应该是一种“多种花样”的语言。正是因为Stroustrup这种高瞻远瞩的构想，才使得C
神奇的BOOST_MPL_ASSERT_MSG,神奇的解决方案,神奇的vc的bug
土星·北海若
03-08 5731
运行环境VC2005.工程里面写了这么一段代码,目的是为了实现DWORDDWORD*之间完成转型而不报warningtemplate typename Obj_T, typename Src_T>Obj_T  union_cast(Src_T src)...{    // 编译期检查Src_T和Obj_T的数据大小是一致。    //    BOOST_MPL_ASSERT_MSG(s
std::make_index_sequence去访问vector
最新发布
10-22
`std::make_index_sequence`是C++14引入的一个模板工具，用于生成一系列连续的整数序列，常用于索引操作或动态数组大小的确定。当你有一个`std::vector`容器，并想要按照某种顺序遍历它的元素，例如从0到`std::...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yshuise

权术横行

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值