c++-模板元编程编译期插入排序

#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 

#include 
#include 


using namespace std;

template
struct TypeList {
};

template
struct FrontTypeT;

template
struct FrontTypeT> {
    using type = Front;
};

template
using FrontType = typename FrontTypeT::type;

template
struct PopFrontT;

template
struct PopFrontT> {
    using type = TypeList;
};

template
using PopFront = typename PopFrontT::type;

template
struct PushFrontT;

template
struct PushFrontT, NewElem> {
    using type = TypeList;
};

template
using PushFront = typename PushFrontT::type;

template
struct PushBackT;

template
struct PushBackT, NewElem> {
    using type = TypeList;
};

template
using PushBack = typename PushBackT::type;


template
struct TypeListSize;

template
struct TypeListSize {
    constexpr static auto value = 1 + TypeListSize>::value;
};

template::value)>
struct NthElementT;

template
struct NthElementT : public NthElementT, N - 1> {
};

template
struct NthElementT : public exception {
};

template
struct NthElementT : public FrontTypeT {
};

template
using NthElement = typename NthElementT::type;

template<>
struct TypeListSize> {
    constexpr static auto value = 0;
};

template
struct IsEmpty {
    constexpr static auto value = false;
};

template<>
struct IsEmpty> {
    constexpr static auto value = true;
};

template::value>
struct ReverseT;

template
struct ReverseT {
    using Front = FrontType;
    using Tail = typename ReverseT>::type;
    using type = PushBack;
};

template<>
struct ReverseT, true> {
    using type = TypeList<>;
};

template
using Reverse = typename ReverseT::type;

// 继承实现
//template::value>
//struct ReverseT2;
//
//template
//using Reverse2 = typename ReverseT2::type;
//
//
//template
//struct ReverseT2 : public PushBackT<
//        Reverse2>,
//        FrontType> {
//};
//template<>
//struct ReverseT2, true> {
//    using type = TypeList<>;
//};


template
struct PopBackT : public ReverseT>> {
};

template
using PopBack = typename PopBackT::type;

template
struct Index_Sequence {
};

template
struct Make_Index_Sequence : public Make_Index_Sequence {
};

template
struct Make_Index_Sequence<0, 0, Others...> {
    using type = Index_Sequence<0, Others...>;
};

template
struct Make_Index_Sequence2 {
    using type = typename Make_Index_Sequence::type;
};

template
struct Make_Index_Sequence2<0, 0, Others...> {
    using type = Index_Sequence<0, Others...>;
};

template
using myIndex_Sequence = typename Make_Index_Sequence2::type;

template
void print(Args &&...args) {
    (cout << ... << args) << endl;
}

template
struct AddSpace {
    const T &ref;

    AddSpace(const T &t) : ref(t) {}

    friend ostream &operator<<(ostream &os, const AddSpace &obj) {
        os << obj.ref << " ";
        return os;
    }
};

template
void print(Index_Sequence, Tuple t) {
    (cout << ... << AddSpace(t))>(get(t)));
}

template typename metaFunc, bool = IsEmpty::value>
struct TransformT;

template typename metaFunc>
using Transform = typename TransformT::type;


//template typename metaFunc>
//struct TransformT {
//    using Rest = typename TransformT, metaFunc>::type;
//    using NewFront = typename metaFunc>::type;
//    using type = PushFront;
//};

// 继承实现
// 是一种递归方式, 从后往前操作
// 1. pop, 并得到值
// 2. 到临界条件
// 3. 对该值进行处理
template typename metaFunc>
struct TransformT
        : public PushFrontT, metaFunc>, typename metaFunc>::type> {

};

template typename metaFunc>
struct TransformT {
    using type = List;
};


template typename metaFunc, typename Init, bool = IsEmpty::value>
struct AccumulateT;

template typename metaFunc, typename Init>
using Accumulate = typename AccumulateT::type;

template typename metaFunc, typename Init>
struct AccumulateT : public AccumulateT<
        PopFront,
        metaFunc,
        typename metaFunc>::type
> {
};

template typename metaFunc, typename Init>
struct AccumulateT {
    using type = Init;
};

template
struct LargerType {
    using type = conditional_t= sizeof(U), T, U>;
};

// 使用继承的目的是因为, 可以指定Init类型
template::value>
struct LargestTypeAccT : public AccumulateT, LargerType, FrontType> {
};

// 哨兵
template
struct LargestTypeAccT {
    using type = char;
};

template
using LargestTypeAcc = typename LargestTypeAccT::type;

template
struct Identity {
    using type = T;
};

template typename Compare, bool = IsEmpty::value>
struct InsertSortT;

template typename Compare>
using InsertSort = typename InsertSortT::type;

template typename Compare>
struct InsertSortT {
 private:
    using Front = FrontType;
    using NewTail = typename conditional_t::value, Identity, InsertSortT, Elem, Compare>>::type;
    using NewHead = conditional_t::value, Elem, Front>;
 public:
    using type = PushFront;
};

template typename Compare>
struct InsertSortT {
    using type = PushFront;
};

template typename Compare, bool = IsEmpty::value>
struct InsertionSortT;

template typename Compare>
using InsertionSort = typename InsertionSortT::type;

template typename Compare>
struct InsertionSortT {
 private:
    using Front = FrontType;
    using SortList = typename InsertionSortT, Compare>::type;
 public:
    using type = typename InsertSortT::type;
};

template typename Compare>
struct InsertionSortT {
    using type = List;
};

template
struct LessSize {
    constexpr static auto value = sizeof(T) < sizeof(U);
};

int main() {
    using SL = TypeList;
    InsertionSort sis;
    cout << boost::typeindex::type_id_with_cvr().pretty_name() << endl;
}
c++-模板元编程 编译期插入排序

C/C++/C#相关栏目本月热门文章

c++-模板元编程编译期插入排序
