1) 获取类型特征typeTraits [原创,泛型编程,自由下载转载，需注明出处]

最新推荐文章于 2023-02-10 21:32:25 发布
最新推荐文章于 2023-02-10 21:32:25 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 原创的泛型库(完整代码见我的下载资源，本库已应用于项目) 文章标签： C++ Meta programming STL general library 源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tonny0832/article/details/12382911
版权

源代码可以在我的资源中去下载(包括用法测试的源代码):
http://download.csdn.net/detail/tonny0832/7426991
只需要用VS建一个空的工程，然后引入我的测试头文件即可。然后测试函数会在main函数之前运行，在控制台窗口中可以看到输出。


由于在我们的项目中，不能使用std及其它的主流库(boost等)，在需要判断一些类型特征及类型转换时，就只能自己写这些功能了。所以为了元代码的需要，我在我们的项目们自己写了这些type trait代码。

type trait是一切模板元编程的基础组件，所以它应该是模板元编程中非配置/宏定义功能集中的第一个文件，type trait(类型特征)如同普通编程中的if..else判断一样广泛使用，它通常决定了链接器在链接时应该链接哪个函数，在编译器识别正确的类型时，它也是必须的组件。

这方面功能的实现当然是boost实现得更好：如果在你的项目中允许使用boost这种重量级的库时，那么还是推荐你使用boost，如果不能，那么这些源代码可供替代使用)

这个文件定义了实现了一些基本的功能：判断一个类型是否是引用/指针/voliate/常量/函数指针，是否是STL容器，是否数组，是否内置类型，是否原子数据，比较两个带修饰符类型是否相同，是否不带修饰符类型相同，两个类型是否可以转换，是否两个类型的值可以相互转换(char==>int)，两个类型是否具有派生关系。

取得一个类型的原始类型(e.g.  const int&==> int)，

取得一个指针/智能指针/迭代器所指示的(第一级)值类型(e.g.  smartPtr<int> ==> int   / int* ==> int / vector<int>::iterator ==> int  )

取得一嵌套指针/智能指针/迭代器的最终值类型(非指针/智能指针/迭代器类型)，e.g ：int*==>int, int** ==> int , int*** == >int  / vector<list<vector<int>::iterator>::iterator>::iterator ==> int / smartPtr<smartPtr<int> > ==> int


#ifndef typeTrait_h__
#define typeTrait_h__
#include "libconfig.h"
#include "typeTraits.h"
#include "placeHolder.h"
#include "typeLogic.h"


/********************************************************************
Description : capture type's property, and it is independent on OS and compiler.
                      e.g. isConst , IsVolatile , isReference , isPointer,isBuildInType
                      getRawType of QualifiedType(e.g. raw type of "const int*" is int )
                      isRawType , isSameType , IsBaseDerive, IsConvertable , IsValueConvertable
Author : Shen.Xiaolong (Shen Tony) (2010-2013)
Mail : xlshen2002@hotmail.com,  xlshen@126.com
verified platform : VS2008
copyright:          : latest Version of The Code Project Open License (CPOL : http://www.codeproject.com/)
*********************************************************************/


#ifdef _MSC_VER
#pragma warning(disable:4244)
#endif


#define SA(X,Y)         typename SameAllQualifier<X,Y>::type            //Set X by Y  (Same All Qualifier)
#define SC(X,Y)         typename SameConst<X,Y>::type                   //Set X by Y  (Same Const)
#define DC(X)           typename Evl_If_T<IsConst<X>,RemoveConst<X>,AddConst<X> >::type::type


#define RT(X)           typename AddRef<X>::type                        //always get reference type
#define NR(X)           typename RemoveRef<X>::type                     //always get non-reference type
#define VT(X)           typename GetValueTypeFromPointer<X>::type                  //get value type from pointer type


#define RAWTYPE(X) typename UtilExt::GetRawType<X>::type


namespace UtilExt
{  
/
    struct        NullType;
    typedef char            Yes_Type;
    typedef struct { char dummy[2]; }            No_Type;


    template<bool x> struct BoolType        { enum  { value=(x)         };  };
    struct  TrueType      : BoolType<true>  { };
    struct  FalseType     : BoolType<false> { };
/
    
    template<typename T>    struct Type2Type    { typedef T type;       };


    //Int2Type::value is compile-period constant expression, it can apply for compile period calculation, e.g Static_Assert
    //and the T can only integer or enum type
    template<int Val>       struct Int2Type     { enum { value=Val  };  };


    //Value2Type::value is not compile-period constant expression, it can't apply for compile period calculation, e.g Static_Assert
    //but it works well in runtime period, and it can hold non-integer type, e.g. function pointer, member pointer etc.
    template<typename T,T Val>  struct  Value2Type   : public Type2Type<T>   { static const T value; };
    template<typename T,T Val>  T const Value2Type<T,Val>::value=Val;


    template<typename T,T Val,template<class T,T Val> class Impl_T>  
    typename Impl_T<T,Val>::type         getTypeValue(Impl_T<T,Val> const&) { return Val;           };


//forward declaration and helper///
    template<typename T>                        struct IsStlIterator;
    template<typename T>                        struct sfinae_helper                            : Type2Type<NullType>   {}; 
    
    //if T has not nested 'type', then nested 'type' is T itself , else nested 'type' is 'T::type'
    template<typename T,typename P=NullType>    struct GetNestedType : public Type2Type<T>                                            {};
    template<typename T> struct GetNestedType<T,typename sfinae_helper<typename T::type>::type> : public Type2Type<typename T::type>  {};


    //if T has not nested 'value', then nested 'value' is T itself , else nested 'value' is 'T::value'
    template<typename T,bool b=(0!=T::value)>   struct GetBoolValue                             : BoolType<b>   {};     //No test code
    template<bool   b>                          struct GetBoolValue<bool,b>                     : BoolType<b>   {};     //No test code


if..else... select interfaces /
//default is true
    template<bool,typename True_T,typename False_T>         struct If_T                         : Type2Type<True_T>     {} ;
template<typename True_T,typename False_T>              struct If_T<false,True_T,False_T>   : Type2Type<False_T>    {} ;
    template<typename B,typename True_T,typename False_T>   struct Evl_If_T                     : public If_T<GetBoolValue<B>::value,True_T,False_T> {};


    template<template<class> class T>                       struct AddRemoveTrait;
    template<template<class> class AddQualifier_T, template<class> class RemoveQualifier_T>
    struct AddRemoveDef
    {
        typedef AddQualifier_T<_1>                  Add_T;
        typedef RemoveQualifier_T<_1>               Remove_T;
    }; 


    Is interfaces /
    template<typename T>    struct IsRef            : FalseType {}; 
    template<typename T>    struct IsRef<T&>        : TrueType  {};
    template<>              struct IsRef<void>      : FalseType {};


    template<typename T>    struct AddRef           : public Type2Type<T&>  {};
    template<typename T>    struct AddRef<T&>       : public Type2Type<T&>  {};
    template<>              struct AddRef<void>     : public Type2Type<void>{};
    template<typename T,unsigned int LEN>   struct AddRef<T(&)[LEN]>    : public Type2Type<T(&)[LEN]>  {};
    template<typename T,unsigned int LEN>   struct AddRef<T[LEN]>       : public Type2Type<T(&)[LEN]>  {};




    template<typename T>    struct RemoveRef        : public Type2Type<T>   {};
    template<typename T>    struct RemoveRef<T&>    : public Type2Type<T>   {};
    template<>              struct RemoveRef<void>  : public Type2Type<void>{};
    template<typename T,unsigned int LEN>   struct RemoveRef<T(&)[LEN]>    : public Type2Type<T[LEN]>  {};
    template<typename T,unsigned int LEN>   struct RemoveRef<T[LEN]>       : public Type2Type<T[LEN]>  {};


    template<> struct AddRemoveTrait<IsRef> : public AddRemoveDef<AddRef,RemoveRef>                         {};
    /
    template<typename T>    struct IsSmartPointer                   : FalseType {};
    template<typename T>    struct IsSmartPointer<stlSmartptr<T> >  : TrueType  {};


    template<typename T>            struct IsMemberPointer          : FalseType {};
    template<typename S,typename M> struct IsMemberPointer<M S::*>  : TrueType  {};


    template<typename T>    struct IsPointer                        : logic::Or_T< IsSmartPointer<T> , IsStlIterator<T> > {};
    template<typename T>    struct IsPointer<T*>                    : TrueType  {};    
    template<typename T>    struct IsPointer<T*&>                   : TrueType  {};    


    template<typename T,typename S=NullType>    struct  AddPointerImpl  : Type2Type<typename RemoveRef<T>::type*>   {}; //pointer to reference is illegal
    template<typename T>    struct  AddPointerImpl<T,typename sfinae_helper<typename T::iterator_category>::type>   : Type2Type<T> {};
    
    template<typename T>    struct AddPointer                   : AddPointerImpl<T>                             {}; 
    template<typename T>    struct AddPointer<T*>               : Type2Type<T*>                                 {};
    template<typename T>    struct AddPointer<T&>               : Type2Type<T*&>                                {};
    template<typename T>    struct AddPointer<T*&>              : Type2Type<T*&>                                {};
    template<typename T>    struct AddPointer<stlSmartptr<T> >  : Type2Type<stlSmartptr<T> >                    {}; //TODO : Not tested, No test code


    template<typename T,typename S=NullType>    struct  RemovePointerImpl                                              : Type2Type<T>                       {}; 
    template<typename T>    struct  RemovePointerImpl<T,typename sfinae_helper<typename T::iterator_category>::type>   : Type2Type<typename T::value_type>  {};
    
    template<typename T>    struct RemovePointer                : RemovePointerImpl<T>                          {};
    template<typename T>    struct RemovePointer<T*>            : Type2Type<T>                                  {};
    template<typename T>    struct RemovePointer<T*&>           : Type2Type<T&>                                 {};
    template<typename T>    struct RemovePointer<stlSmartptr<T> >:Type2Type<T>                                  {};    //TODO : Not tested, No test code


    template<> struct AddRemoveTrait<IsPointer> : public AddRemoveDef<AddPointer,RemovePointer>                 {};


    /
    template<typename T>                    struct IsConst                      : FalseType {}; 
    template<typename T>                    struct IsConst<const T>             : TrueType  {};
    template<typename T>                    struct IsConst<const T&>            : TrueType  {};
    template<typename T>                    struct IsConst<T const*>            : TrueType  {}; //pointer point to constant ,pointer can be moved.
    template<typename T>                    struct IsConst<T const* const>      : TrueType  {}; //pointer point to constant ,pointer can be moved.
    template<typename T>                    struct IsConst<T* const>            : FalseType {}; //const pointer point to variable, pointer can't be moved
    template<typename T,unsigned int LEN>   struct IsConst<T[LEN]>              : FalseType {}; //array style
    template<typename T,unsigned int LEN>   struct IsConst<const T[LEN]>        : TrueType  {}; //array style
    template<typename T,unsigned int LEN>   struct IsConst<T(&)[LEN]>           : FalseType {}; //array ref style
    template<typename T,unsigned int LEN>   struct IsConst<const T(&)[LEN]>     : TrueType  {}; //array ref style


    template<typename T>                    struct AddConst                 : Type2Type<typename Evl_If_T<IsPointer<T>,typename RemovePointer<T>::type const*,T const>::type >{};
    template<typename T>                    struct AddConst<T&>             : Type2Type<T const&>       {}; 
    template<typename T>                    struct AddConst<T const&>       : Type2Type<T const&>       {}; 
    template<typename T>                    struct AddConst<T const>        : Type2Type<T const>        {};
    template<typename T>                    struct AddConst<T const*>       : Type2Type<T const*>       {};     //pointer point to constant ,pointer can be moved.
    template<typename T>                    struct AddConst<T const* const> : Type2Type<T const* const> {};    //pointer point to constant ,pointer can be moved.
    template<typename T>                    struct AddConst<T* const>       : Type2Type<T const*>       {};    //const pointer point to variable, pointer can't be moved
    template<typename T,unsigned int LEN>   struct AddConst<T[LEN]>         : Type2Type<const T[LEN]>   {};    //array style
    template<typename T,unsigned int LEN>   struct AddConst<const T[LEN]>   : Type2Type<const T[LEN]>   {};    //array style
    template<typename T,unsigned int LEN>   struct AddConst<T(&)[LEN]>      : Type2Type<const T(&)[LEN]>{};     //array ref style
    template<typename T,unsigned int LEN>   struct AddConst<const T(&)[LEN]>: Type2Type<const T(&)[LEN]>{};    //array ref style


    template<typename T>                    struct RemoveConst                  : Type2Type<T>          {};
    template<typename T>                    struct RemoveConst<T&>              : Type2Type<T&>         {}; 
    template<typename T>                    struct RemoveConst<T const&>        : Type2Type<T&>         {}; 
    template<typename T>                    struct RemoveConst<T const>         : Type2Type<T>          {};
    template<typename T>                    struct RemoveConst<T const*>        : Type2Type<T*>         {};    //pointer point to constant ,pointer can be moved.
    template<typename T>                    struct RemoveConst<T const* const>  : Type2Type<T*>         {};    //pointer point to constant ,pointer can be moved.
    template<typename T>                    struct RemoveConst<T* const>        : Type2Type<T*>         {};    //const pointer point to variable, pointer can't be moved
    template<typename T,unsigned int LEN>   struct RemoveConst<T[LEN]>          : Type2Type<T[LEN]>     {};    //array style
    template<typename T,unsigned int LEN>   struct RemoveConst<const T[LEN]>    : Type2Type<T[LEN]>     {};     //array style
    template<typename T,unsigned int LEN>   struct RemoveConst<T(&)[LEN]>       : Type2Type<T (&)[LEN]> {};    //array ref style
    template<typename T,unsigned int LEN>   struct RemoveConst<const T(&)[LEN]> : Type2Type<T (&)[LEN]> {};    //array ref style


    template<> struct AddRemoveTrait<IsConst> : public AddRemoveDef<AddConst,RemoveConst>{};
    /
    template<typename T>    struct IsVolatile                   : FalseType {}; 
    template<typename T>    struct IsVolatile<volatile T>       : TrueType{};


    template<typename T>    struct AddVolatile                  : Type2Type<volatile T> {};
    template<typename T>    struct AddVolatile<volatile T>      : Type2Type<volatile T> {};


    template<typename T>    struct RemoveVolatile               : Type2Type<T> {};
    template<typename T>    struct RemoveVolatile<volatile T>   : Type2Type<T> {}; 


    template<> struct AddRemoveTrait<IsVolatile> : public AddRemoveDef<AddVolatile,RemoveVolatile>{};
    /
#if HAS_BOOST_SUPPORT==0
    //only max support 5 parameter
    template<typename T>    struct IsFunctionPointer : FalseType {};
    template<typename R>    struct IsFunctionPointer<R (*)()>      : TrueType {};
    template<typename R>    struct IsFunctionPointer<R (*)(...)>   : TrueType {};
    template<typename R,typename P1> struct IsFunctionPointer<R (*)(P1)>       : TrueType {};
    template<typename R,typename P1> struct IsFunctionPointer<R (*)(P1,...)>   : TrueType {};
    template<typename R,typename P1,typename P2>    struct IsFunctionPointer<R (*)(P1,P2)>     : TrueType {};
    template<typename R,typename P1,typename P2>    struct IsFunctionPointer<R (*)(P1,P2,...)> : TrueType {};
    template<typename R,typename P1,typename P2,typename P3>    struct IsFunctionPointer<R (*)(P1,P2,P3)>      : TrueType {};
    template<typename R,typename P1,typename P2,typename P3>    struct IsFunctionPointer<R (*)(P1,P2,P3,...)>  : TrueType {};
    template<typename R,typename P1,typename P2,typename P3,typename P4>    struct IsFunctionPointer<R (*)(P1,P2,P3,P4)>       : TrueType {};
    template<typename R,typename P1,typename P2,typename P3,typename P4>    struct IsFunctionPointer<R (*)(P1,P2,P3,P4,...)>   : TrueType {};
    template<typename R,typename P1,typename P2,typename P3,typename P4,typename P5>    struct IsFunctionPointer<R (*)(P1,P2,P3,P4,P5)>       : TrueType {};
    template<typename R,typename P1,typename P2,typename P3,typename P4,typename P5>    struct IsFunctionPointer<R (*)(P1,P2,P3,P4,P5,...)>   : TrueType {};


    template<typename T>    struct IsMemberFunctionPointer : FalseType {};
    template<typename R,typename O>    struct IsMemberFunctionPointer<R (O::*)()>      : TrueType {};
    template<typename R,typename O>    struct IsMemberFunctionPointer<R (O::*)(...)>   : TrueType {};
    template<typename R,typename O,typename P1> struct IsMemberFunctionPointer<R (O::*)(P1)>       : TrueType {};
    template<typename R,typename O,typename P1> struct IsMemberFunctionPointer<R (O::*)(P1,...)>   : TrueType {};
    template<typename R,typename O,typename P1,typename P2>    struct IsMemberFunctionPointer<R (O::*)(P1,P2)>     : TrueType {};
    template<typename R,typename O,typename P1,typename P2>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,...)> : TrueType {};
    template<typename R,typename O,typename P1,typename P2,typename P3>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,P3)>      : TrueType {};
    template<typename R,typename O,typename P1,typename P2,typename P3>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,P3,...)>  : TrueType {};
    template<typename R,typename O,typename P1,typename P2,typename P3,typename P4>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,P3,P4)>       : TrueType {};
    template<typename R,typename O,typename P1,typename P2,typename P3,typename P4>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,P3,P4,...)>   : TrueType {};
    template<typename R,typename O,typename P1,typename P2,typename P3,typename P4,typename P5>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,P3,P4,P5)>       : TrueType {};
    template<typename R,typename O,typename P1,typename P2,typename P3,typename P4,typename P5>    struct IsMemberFunctionPointer<R (O::*)(P1,P2,P3,P4,P5,...)>   : TrueType {};
#endif
    /    
    template<typename T>    struct GetRawType;       //forward declaration, below interface will use GetRawType interface
    template<typename T1, typename T2>  struct IsSameType       : FalseType {}; 
    template<typename T>                struct IsSameType<T,T>  : TrueType  {};
    template<typename T1, typename T2>  struct IsSameRawType    : IsSameType<typename GetRawType<T1>::type,typename GetRawType<T2>::type>{};
    
    template<typename T>                struct IsRawType        : IsSameType<T,typename GetRawType<T>::type> {};


    /
    template<typename T>
    struct IsStlIterator
    {   //borrow idea from boost lib
        template<typename U,typename S=NullType>    struct IsIteratorImpl                                               : FalseType {};
        template<typename U>    struct IsIteratorImpl<U,typename sfinae_helper<typename U::iterator_category>::type>    : TrueType  {};


        enum{value=IsIteratorImpl<T>::value};     //PrivateHelper::TypeHelper
    };


    template<typename T>
    struct IsStlContainer
    {  
        //borrow idea from boost lib
        template<typename U,typename S=NullType>    struct CHasIterator                                     : FalseType {};
        template<typename U>    struct CHasIterator<U,typename sfinae_helper<typename U::iterator>::type>   : TrueType  {};


        enum{value= logic::And_T<logic::Not_T<IsDataSet<T> >,CHasIterator<RAWTYPE(T)> >::value};
    };


    template<typename T>
    struct IsIterator 
        : logic::Or_T <logic::And_T<IsPointer<T>,logic::Not_T<IsSmartPointer<T> > ,logic::Not_T<IsFunctionPointer<T> > ,logic::Not_T<IsMemberFunctionPointer<T> > >,IsStlIterator<T> >{};
    /
    template<typename S> struct GetValueTypeFromPointer
    {
    public:
        template<bool bisIterator> struct CImpl;
        template<> struct CImpl<true>
        {
            template<typename T> struct apply
            {
                typedef typename T::value_type  type;
            };
        };


        template<> struct CImpl<false>
        {
            template<typename T> struct apply
            {
                typedef T  type;
            };
        };


        typedef  typename CImpl<IsIterator<S>::value>::template apply<S>  H;


    public:
        typedef typename H::type    type;
    };


    template<typename T>    struct GetValueTypeFromPointer<stlSmartptr<T> >    : Type2Type<T> {};
    template<typename T>    struct GetValueTypeFromPointer<T*>                 : Type2Type<T> {};


    template<typename T>    struct GetFinalValueType : Evl_If_T<IsPointer<typename GetValueTypeFromPointer<T>::type >,GetFinalValueType<typename GetValueTypeFromPointer<T>::type>,GetValueTypeFromPointer<T> >::type {};


    /


    namespace PrivateHelper
    {  
        template<typename FromT,typename ToT> struct ConvertHelper
        {   
            static UtilExt::No_Type test(...);
            static UtilExt::Yes_Type    test(ToT);
static FromT    makeFrom();


            enum {value = sizeof(UtilExt::Yes_Type) == sizeof(test(makeFrom())) };
        };
    }
    
    //Note : int and int* is not convertable , because they are different type : int type and pointer type
//similar with char and char*, sizeof(char)=1,sizeof(char*)=4
    template<typename FromT, typename ToT>  struct IsConvertable
    {//in order to independent on OS and compiler , don't use MS specific : __is_convertible_to 
        enum {value    = PrivateHelper::ConvertHelper<FromT,ToT>::value };
    };


    //Note : int and int* is not convertable , but they are value convertable.
    template<typename FromT, typename ToT>  struct IsValueConvertable
    {
    private:    
        typedef PrivateHelper::ConvertHelper<typename GetValueTypeFromPointer<FromT>::type,typename GetValueTypeFromPointer<ToT>::type>   H;


    public:
        enum {value    = H::value };
    };


    /


    template<typename BaseT, typename DeriveT>  struct IsBaseDerive
    { //in order to independent on OS and compiler , don't use MS specific : __is_base_of 
    private:
        typedef PrivateHelper::ConvertHelper<typename GetRawType<typename AddPointer<DeriveT>::type>::type,typename GetRawType<typename AddPointer<BaseT>::type>::type>   H;  
        //filter int/char/float convertible


    public:
        enum { value = logic::And_T<H,logic::Not_T<IsSameRawType<BaseT,DeriveT> > >::value };
    };


    template<typename DeriveT>  struct IsBaseDerive<void,DeriveT>
    {
        enum {value = false};
    };


    /


    template<typename BaseT, typename DeriveTOrBaseT>  struct IsSerialClass : logic::Or_T<IsBaseDerive<BaseT,DeriveTOrBaseT>,IsSameRawType<BaseT,DeriveTOrBaseT> >{};


    /


    template<typename S> struct isArray              : FalseType {};  //array pointer is not array
template<typename S,unsigned int LEN> struct isArray<S[LEN]>      : TrueType  {};
template<typename S,unsigned int LEN> struct isArray<S(&)[LEN]>   : TrueType  {};


    /


    template<typename S>    struct ArraySize            : Int2Type<0>   {}; //for pass compiler graceful
    template<typename S,unsigned int LEN> struct ArraySize<S[LEN]>    : Int2Type<LEN> {};
    template<typename S,unsigned int LEN> struct ArraySize<S(&)[LEN]> : Int2Type<LEN> {};


    /


    template<typename T>        struct isAtomType
    {
        template<typename C> static UtilExt::Yes_Type test(...);    //SFINAE    : capture default    type
        template<typename C> static UtilExt::No_Type test(bool C::*);    //SFINAE    : capture customized type


        enum { value = logic::And_T<logic::Not_T<isArray<T> > , BoolType<sizeof(test<T>(0)) == sizeof(UtilExt::Yes_Type)> >::value };
    };


    /


    template<typename T>        struct isBuildInType 
    {
    private:
        typedef typename GetRawType<T>::type rawT;
        template<typename U>    struct tester: IsSameType<rawT,U> {};


    public:
        enum{value=logic::Or_T<
            logic::Or_T<IsPointer<T>,       tester<__int64>,    tester<unsigned __int64>                                                    >,
            logic::Or_T<tester<bool>,       tester<char>,       tester<unsigned char>,      tester<signed char>                             >,
            logic::Or_T<tester<wchar_t>,    tester<short>,      tester<unsigned short>,     tester<int>,            tester<unsigned int>    >,
            logic::Or_T<tester<float>,      tester<long>,       tester<unsigned long>,      tester<double>,         tester<long double>     > >::value };
        /* below comes from C++ primer chapter 3, other is default
        bool                        //ANSI/ISO C++ 
        wchar_t                     //unicode , compiler dependency
        float                       //ANSI/ISO C++     
        double                      //ANSI/ISO C++     
        __int64                     //C99
        unsigned __int64            //C99     
        long double                 //ANSI/ISO C++
        IsPointer                   //default pointer
        */
    };


    //because array doesn't support operator "="   , when it is copied and transfer , it will be degraded and correct transfer has performance consumption
template<typename T,unsigned int LEN> struct isBuildInType<T[LEN]>        : FalseType{};


    //because array doesn't support operator "=" , and it can be copy and transfer without performance consumption by reference
template<typename T,unsigned int LEN> struct isBuildInType<T(&)[LEN]>     : TrueType{};


    /
template<typename T>    struct isEnumType
{
        enum {value = logic::And_T<BoolType<sizeof(enum EnumType)==sizeof(T)>,isAtomType<T>,logic::Not_T<isBuildInType<T> > >::value };
};


    /    
    template<typename T>
    struct isString
    {
    protected:
        template<typename U>    struct StlStringHelper
            : public BoolType<logic::Or_T<IsSameRawType<U,stlStringA> ,IsSameRawType<U,stlStringW> ,IsSameRawType<U,stlString> >::value >{};


        template<typename T>                    struct isCharArray  : public BoolType<false>{};
        template<typename T,unsigned int iLen>  struct isCharArray<T[iLen]> 
        : public BoolType<logic::Or_T<IsSameRawType<T,wchar_t>,IsSameRawType<T,char> >::value> {};




    public:
        enum {
            value = IsSameRawType<T,char*>::value          || 
            IsSameRawType<T,wchar_t*>::value               ||
            isCharArray<T>::value                          || 
            StlStringHelper<T>::value           
        };
    };


    /


    template<typename T>    struct GetRawType : public RemoveVolatile<typename RemoveConst<typename RemoveRef<T>::type>::type>  {};
} 


#ifdef _MSC_VER
#pragma warning(default:4244)
#endif
#endif // typeTrait_h__

shenxiaolong1976
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【STL源码阅读】type_traits
DUT_LYH
10-24 285
traits：萃取机 用来获取类型，回答问题的 例如 is_void is_null_pointer等 https://en.cppreference.com/w/cpp/header/type_traits .实现机制下面实现一个`is_int`对于是够是int的提问对于其他类型直接继承m_false_type表示不是int类型对于int类型继承了m_true_type完整代码 实现机制 template <class T, T v> struct m_integral_constant .
泛型编程与设计新思维[原创]
02-04
---HerbSutter1998年，国际C++标准正式通过，标准化对C++最重要的贡献是：对“强大的抽象概念”给于更有力的支持，以降低软件的复杂度，C++提供了二种功能强大的抽象方法：面向对象编程与泛型编程。面向对象编程大家...
C/C++编程：Type Trait
OceanStar的博客
07-25 1082
type trait
C++ traits学习笔记（二）
weixin_33717298的博客
01-19 124
这是我学习traits翻译的第二篇文章，原文地址：http://accu.org/index.php/journals/442，有不当的地方请过路的朋友指教，谢谢！ 翻译文章也怪不容易的，转载请注明出处，感谢！ 不同的代码片段具有相同的结构，仅在实现细节方面有所不同，这是一种常见的情形。因此我们可以重用相同的部分，只对于有差别的那些细节，针对不同的需求进行实现。在C语言中，可以通过函数指针实现...
trait编程技法
uu
12-02 1032
traits技法简单入门首先要对元编程有所了解,要知道模板类，如果用过STL就更好了。我最早是在STL源码剖析一书中看到trait技法的，运用这一技法将本来在runtime时完成的工作转到了编译时期完成。下面是一个通常用来作示例的，关于元编程的例子，读者自己去体会。struct fibonacci{       enum{value=fibonacci::value+f
C++标准模板库type_traits源码剖析
最新发布
qq_43148810的博客
02-10 1180
1、type_traits是C++11提供的模板元基础库。2、type_traits可实现在编译期计算。包括添加修饰、萃取、判断查询、类型推导等等功能。3、type_traits提供了编译期的true和false。
Java 获取泛型的类型实例详解
08-30
Java 中获取泛型的类型实例是指在 Java 语言中获取泛型类型的实例对象的类型信息，泛型是 Java 语言中的一种重要特性，允许在编译时检查类型安全，避免类型转换异常，但是在实际开发中，获取泛型的类型实例卻是一件...
Java如何获取泛型类型
01-21
参考：我眼中的Java-Type体系(1) 我眼中的Java-Type体系(2) 秒懂Java类型（Type）系统 Java 运行时如何获取泛型参数的类型 Java类型Type 之 ParameterizedType，GenericArrayType，TypeVariabl，WildcardType 从实现...
C++ 泛型编程详解
01-21
但是面向对象编程强调编程的数据方面，泛型编程强调的是独立于特定数据类型。 这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程，这一篇主要介绍函数模板、类模板和成员模板三大部分 如有侵权，请...
C语言泛型编程实例教程
01-01
首先，泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。在C语言中，可以通过一些手段实现这样的泛型编程。这里介绍一种方法——通过无类型指针void* 看下面的一个实现...
《STL源码剖析》之type_traits
liyucheng777的博客
12-03 323
STL中的traits操作（类型萃取）
type_traits
Nemo
07-29 2702
概述 type_traits提供了丰富的编译期间计算、查询、判断、转换和选择的帮助类，其被定义在#include <type_traits>下。 作用： 增强了泛型编程能力； 增强程序的弹性，使得在编译期间就可以做到优化、改进甚至排错，提高代码质量； 它所提供的选择功能一定程度上可以消除冗长的if-else或switch-case语句，降低程序的圈复杂度，提高代码的可...
C++11 类型支持之type traits
wxj1992的博客
01-16 7033
如果你是一个c++模板用户，大概率多多少少都接触过type traits这个概念，直译就是类型萃取，根据名字也能猜到是用于获取类型的，在c++ 11之前，stl就已经用到了相关技术了，比如迭代器使用相关的类型获取，《STL 源码剖析》有详细介绍，有兴趣的可以去看看。c++ 11更是引入了一个专门的头文件<type_traits>用来做type traits的相关事情，本篇就来聊聊type_traits。
活用C++模板之traits
weixin_34221036的博客
08-21 839
介绍traits的文章很多，但感觉大部分文章的说明都很晦涩难懂，把一个并不很复杂的C++模板的应用描述的过于复杂。忍不住想把自己的理解跟大家分享一下，或许我也只是掌握了一点traits的皮毛而已，但也希望这些皮毛能略微抓住你的眼球，带给你一些启发。 首先，介绍traits前，回味一下C++的模板及应用，如果你脑海里浮现出的只是为实现一些函数或类的重用的简单模板应用，那我要告诉你，你o...
c++11 之type_traits
lq123的博客
07-25 1760
1.type_traits-类型萃取  （1）type_traits可以在一定程度上消除 switch-case 或者 if-else语句，降低程序的复杂度 （2）可以在编译期就检查出是否是正确类型 1.1基本的type_traits 定义编译期常量   struct GetLeftSize {    static const int value =1; } 或  st
Haskell中的泛型编程实践与类型类扩展
"这篇文章是Ralf Hinze和Simon Peyton Jones合著的一篇关于在Haskell中实现泛型编程的论文，发表在《理论计算机科学电子笔记》第41卷第1期。文章主要探讨了如何在不改变Haskell语言基础或类型系统的情况下，通过扩展...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值