c++11 总结-1

#include 
#include 
#include  //类型萃取
#include 
#include  //typeid
#include    //ptr

using namespace std;

template 
class function_traits;

//通过特化获取返回值
// 基本特化版本
template
struct function_traits{
    enum { arity = sizeof...(Args) };
	using return_type = ReturnType;
	using function_type = ReturnType(Args...);
	using stl_function_type = std::function;
	using pointer = ReturnType(*)(Args...);

	template
	struct args
	{
		static_assert(I < arity, "index is out of range, index must less than sizeof Args");
		using type = typename std::tuple_element>::type;
	};

	using tuple_type = std::tuple>...>;
	using bare_tuple_type = std::tuple>...>;
    
};

//函数指针
template
struct function_traits : function_traits {};

//function
template
struct function_traits> : function_traits {};

// 成员函数
#define FUNCTION_TRAITS(...)
template 
struct function_traits : function_traits{};

FUNCTION_TRAITS()
FUNCTION_TRAITS(const)
FUNCTION_TRAITS(volatile)
FUNCTION_TRAITS(const volatile)

// 函数对象
template
struct function_traits : function_traits {};

//强转成 std::function
template
typename function_traits::stl_function_type to_function(const Function& lambda)
{
	return static_cast::stl_function_type>(lambda);
}
//强转成 std::function
template
typename function_traits::stl_function_type to_function(Function&& lambda)
{
	return static_cast::stl_function_type>(std::forward(lambda));
}
//强转成 函数指针
template
typename function_traits::pointer to_function_pointer(const Function& lambda)
{
	return static_cast::pointer>(lambda);
}

void func(int a,int b) {

}
template
void printType()
{
    cout << typeid(T).name() << endl;
};


float(*cast_func)(int, int, int, int);
float free_function(const string& a, int b)
{
    return (float)a.size() / b;
}
struct AA
{
    int f(int a, int b)volatile { return a + b; }
    int operator()(int)const { return 0; }
};
void test_function_traits()
{
    cout << "----------- 2 ----------" << endl;
    //lambda 
    auto f = [](int a) {return a; };

    //函数
    printType::function_type>();
    //function
    printType>::function_type>();

    //函数
    printType::function_type>();

    //函数指针
    printType::function_type>();
   
    //可调用对象
    printType::function_type>();

    //成员函数
    using T = decltype(&AA::f);
    printType();
    printType::function_type>();

    static_assert(std::is_same::return_type, int>::value, "");
}

支持制定多种类型的复用，很类似union 的用法，内存也是最大类型的大小，并行内存对齐

制定几种类型，可以存放制定类型的数据

1、取类型size的最大值，递归 conditional 2、检查类型 递归，conditional ，利用is_same 判断
3、std::alignment_of 对齐内存，然后根据MaxSize 来获取大小
4、记录下来当前的type_index， 通过type_id 来获取

template 
struct MaxSize : integral_constant::value ? MaxSize::value : sizeof(T)> {
    using maxType = typename std::conditional::value, typename MaxSize::maxType, T>;
};

template 
struct MaxSize : integral_constant {
    using maxType = T;
};


template 
struct CheckType;

template 
struct CheckType
        : std::conditional::value, std::true_type, typename CheckType::type> {};

template 
struct CheckType : std::false_type {};


template 
struct Variant {
    //只能是在类型中才可以构造
    template ::type, T, Args...>::type::value,
                                                       U>::type>
    Variant(U&& u) :m_typeIndex(typeid(typename std::decay::type)) {
        new(&m_data) (typename std::decay::type)(u);
    }

    template
    bool is() {
        return type_index(typeid(U)) == m_typeIndex;
    }
    template
    U Get() {
        if(!is()) {
            throw bad_cast();
        }

        return (*(U*)&m_data);
    }

    // 内存数据m_data;
    using data_t = std::aligned_storage::value, std::alignment_of::type>::value>;
    data_t  m_data;
    type_index m_typeIndex;
};

int main() {
    Variant a = 1;
    int b = a.Get();
    system("pause");
}

#include 
#include 
#include 

using namespace std;

template 
struct TupleHelper {
    static void print(const Tuple &t) {
        TupleHelper::print(t);
        cout << std::get(t) << endl;
    }
};

template 
struct TupleHelper {
    static void print(const Tuple &t) {
        cout << std::get<0>(t) << endl;
    }
};


void test_print() {
    tuple t = make_tuple(1,"a",1);
    TupleHelper::value>::print(t);
}



template 
class Index {

};

template 
struct MakeIndex : MakeIndex {

};

template
struct MakeIndex<0,Args...> {
    using type = Index;
};

//把索引分开
template 
void print(U u) {
    cout << u << endl;
}

template  
void printIndexTuple(Index&& index,const Tuple &t) {
    int arr[] = {(print(get(t)),0)...};
}
template
void index_tuple_print(const tuple &s) {
    printIndexTuple(typename MakeIndex::type(),s);
}

void test_index_tuple_print() {
     tuple t = make_tuple(1,"2",3);
     index_tuple_print(t);
}


template 
struct GetIndex;


template 
struct GetIndex : conditional::value,integral_constant ,GetIndex>::type{

};

template 
struct GetIndex : integral_constant{
};

// 模板很重要的是提取类型，例如：tuple，用下面的的方式就可以提前Args... 类型
template
void get_index_tuple(const tuple &s) {
    cout <<"type" << typeid(T).name() <<" index of" << GetIndex<0,T,Args...>() << endl; 
}

void test_get_index() {
    tuple t = make_tuple(1,"2",3);
    get_index_tuple(t);
}


template
typename enable_if::value>::type 
GetArgIndex(int index, const Tuple &t) {

}

template
typename enable_if::value>::type 
GetArgIndex(int index, const Tuple &t) {
    if(index == K) {
        cout << get(t) << endl;
    } else {
        GetArgIndex(index,t);
    }
}

void test_run_index() {
    tuple t = make_tuple(1,"2",3);
    int a = 1;
    GetArgIndex<0>(a,t);
}


template
auto reverseTupleImp(const Tuple& t, Index index) -> decltype(make_tuple(get(t)...)) {
    return make_tuple(get(t)...);
}

template
auto reverseTuple(const tuple &t) -> decltype(reverseTupleImp(move(t),typename MakeIndex::type())) {
    return reverseTupleImp(t,typename MakeIndex::type());
}
void test_reverse_tuple() {
     tuple t = make_tuple(1,"2",3);
     auto rt = reverseTuple(t);
}