typetraits.t.cpp

高级范型编程

#include "typetraits.h"
#include "staticassert.h"
class VBase{
public:
    virtual ~VBase(){
    }
};
class Base :  public virtual VBase  {
public:
    virtual ~Base(){
    }
};
class Base1 : public Base {
};
class Base2 : public Base {};
class MyClass : public Base1,public Base2{
};
struct MyInt{
	operator int(){return 0;}
};
struct MyInt2{
	operator int(){return 0;}
	int i;
};

enum MyEnum{aaa=90};
int main(){
#if 1
	{//is_same
		enum {is = dnc::is_same<char*,double>::value};
		static_assert(!is,is_same);
	}{
		enum {is = dnc::is_same<const char,char>::value};
		static_assert(!is,is_same);
	}{
		enum {is = dnc::is_same<char,char>::value};
		static_assert(is,is_same);
	}{
		enum {is = dnc::is_same<MyClass,Base>::value};
		static_assert(!is,is_same);
	}
	{//is_array
		enum{is = dnc::is_array<int[]>::value};
		static_assert(is,is_array);
	}{		
		enum{is = dnc::is_array<int>::value};
		static_assert(!is,is_array);
	}
	{//is_enum
		enum{is = dnc::is_enum<int>::value};
		static_assert(!is,is_enum);
	}{		
		enum{is = dnc::is_enum<MyEnum>::value};
		static_assert(is,is_enum);
	}{		
		enum{is = dnc::is_enum<int*>::value};
		static_assert(!is,is_enum);
	}{		
		enum{is = dnc::is_enum<Base>::value};
		static_assert(!is,is_enum);
	}{
		enum{is = dnc::is_enum<MyInt>::value};
		static_assert(!is,is_enum);
	}

	{		
		enum{is = dnc::is_enum<int&>::value};
		static_assert(!is,is_enum);
	}{		
		enum{is = dnc::is_enum<MyInt2>::value};
		static_assert(!is,is_enum);
	}
#endif
	{//is_class
		enum {is = dnc::is_class<int>::value};
		static_assert(!is,is_class);
	}{
		enum {is = dnc::is_class<MyClass>::value};
		static_assert(is,is_class);
	}
#if 1
	{//remove
        typedef dnc::remove_pointer<int*>::type type;
        enum {is = dnc::is_same<type,int>::value};
		static_assert(is,remove_pointer);
    }{
        typedef dnc::remove_pointer<void(*)()>::type type;
        void(*call1)();
        type *call2 = 0;
        call1 = call2;
        call2 = call1;
        call2 = 0;
    }

	{//int2type,type2type
		dnc::int2type<0> obj;
		obj = obj;
		dnc::type2type<int> obj2;
		obj2 = obj2;
	}
	{//selector
		typedef dnc::selector<true,int,double>::type type;
		enum{is = dnc::is_same<type,int>::value};
		static_assert(is,selector);	
	}
	{//selector
		typedef dnc::selector<false,int,double>::type type;
		enum{is = dnc::is_same<type,double>::value};
		static_assert(is,selector);	
	}
	{//is_arithmetic
		enum{is = dnc::is_arithmetic<int>::value};
		static_assert(is,is_arithmetic);	
	}{
		enum{is = dnc::is_arithmetic<Base>::value};
		static_assert(!is,is_arithmetic);	
	}{//is_void
		enum{is = dnc::is_void<void>::value};
		static_assert(is,is_void);	
	}{
		enum{is = dnc::is_void<int>::value};
		static_assert(!is,is_void);	
	}
	{//is_convertible
		enum{is = dnc::is_convertible<MyClass,Base1>::value};
		static_assert(is,is_void);	
	}{
		enum{is = dnc::is_convertible<Base1,Base2>::value};
		static_assert(!is,is_void);	
	}{
		enum{is = dnc::is_convertible<int,double>::value};
		static_assert(is,is_void);
	}{
		enum{is = dnc::is_convertible<MyClass*,VBase*>::value};
        static_assert(is,is_void);
	}
#endif
    
#if 1 //is_base_and_derived
    {
 		enum{is = dnc::is_base_and_derived<int,int>::value};
 		static_assert(!is,is_base_and_derived);	
    }{
 		enum{is = dnc::is_base_and_derived_impl2<Base2,Base1>::value};
        	static_assert(!is,is_base_and_derived);
    }{
#ifdef DNC_CANCHECKBASE
        enum{is = dnc::is_base_and_derived<Base,MyClass>::value};
        static_assert(is,is_base_and_derived);
#else
        enum{is = dnc::is_base_and_derived<VBase,MyClass>::value};
 		static_assert(is,is_base_and_derived);
#endif
 	}{
 		enum{is = dnc::is_base_and_derived<Base1,Base2>::value};
 		static_assert(!is,is_base_and_derived);	
 	}{
 		enum{is = dnc::is_base_and_derived<MyClass,int>::value};
 		static_assert(!is,is_base_and_derived);	
 	}{
#ifdef DNC_CANCHECKBASE
        enum{is = dnc::is_base_and_derived<Base,const MyClass>::value};
        static_assert(is,is_base_and_derived);           
#else
        enum{is = dnc::is_base_and_derived<VBase,const MyClass>::value};
 		static_assert(is,is_base_and_derived);
#endif
 	}{
#ifdef DNC_CANCHECKBASE
 		enum{is = dnc::is_base_and_derived<const Base,volatile MyClass>::value};
 		static_assert(is,is_base_and_derived);
#else
        enum{is = dnc::is_base_and_derived<const VBase,volatile MyClass>::value};
        static_assert(is,is_base_and_derived);
                
#endif
 	}{
 		enum{is = dnc::is_base_and_derived<MyClass,MyClass>::value};
 		static_assert(!is,is_base_and_derived);	
 	}
#endif
	return 0;
}