posts - 5, comments - 10, trackbacks - 0, articles - 0
  C++博客 :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理
作者:flysnwoxg
c++编译器模板解析确实很强大。基本上可以把编译器看做是一个虚拟机,c++模板源代码就是被执行的脚本代码。
基本上你可以在编译期实现任何算法。
下面是一个按照从小到大,然后从大到小对数值对排序的程序,程序使用了冒泡排序,排序在编译期完成。
例如程序的原始输入为: ((5,6),(1,5),(3,4))
将被从小到大排序为  ((1,5),(3,4),(5,6))
然后被从大到小排序为  ((5,6),(3,4),(1,5))


//author:flysnowxg 
#include "stdio.h"
//用模板表示类型,模板的实例化表示对象(如pait_t<1,2> 表示(1,2)这样的两个值的对象)
template<int _first,int _second>
struct pair_t{
    static const int first=_first;
    static const int second=_second;
    static void print(){printf("%d %d",first,second);}
};

//计算两个不同的pair_t类型的实例的小于关系
template <typename T1,typename T2
struct  less_t{
    static const int first_le=T1::first<T2::first;
    static const int first_eq=T1::first==T2::first;
    static const int second_le=(first_eq&&(T1::second<T2::second));
    static const int result=first_le || second_le;
};

//计算两个不同的pair_t类型的实例的大于关系
template <typename T1,typename T2
struct  greate_t{
    static const int result=!less_t<T1,T2>::result;
};

struct null_t;
//类型列表
template <typename T1,typename T2struct list_t;
template <typename T>
struct list_t<T,null_t>{
    typedef T value;
    typedef null_t next;
};
template <typename T1,typename T2,typename T3>
struct list_t<T1,list_t<T2,T3> >
{
    typedef T1 value;
    typedef list_t<T2,T3next
};
#define list_t1(e1list_t<e1,null_t>
#define list_t2(e1,e2list_t<e1,list_t1(e2)>
#define list_t3(e1,e2,e3list_t<e1,list_t2(e2,e3)>
#define list_t4(e1,e2,e3,e4list_t<e1,list_t3(e2,e3,e4)>
#define list_t5(e1,e2,e3,e4,e5list_t<e1,list_t4(e2,e3,e4,e5)>
#define list_t6(e1,e2,e3,e4,e5,e6list_t<e1,list_t5(e2,e3,e4,e5,e6)>
#define list_t7(e1,e2,e3,e4,e5,e6,e7list_t<e1,list_t6(e2,e3,e4,e5,e6,e7)>
#define list_t8(e1,e2,e3,e4,e5,e6,e7,e8list_t<e1,list_t7(e2,e3,e4,e5,e6,e7,e8)>
#define list_t9(e1,e2,e3,e4,e5,e6,e7,e8,e9list_t<e1,list_t8(e2,e3,e4,e5,e6,e7,e8,e9)>
#define list_t10(e1,e2,e3,e4,e5,e6,e7,e8,e9,e10list_t<e1,list_t9(e2,e3,e4,e5,e6,e7,e8,e9,e10)>

//递归打印类型列表中每个类型的值
template<typename Tstruct print_t;
template<typename T>
struct print_t<list_t<T,null_t>>
{
    typedef typename T result;
    static void print(){
        printf("\nelem::");
        result::print();
    }
};
template<typename T1,typename T2>
struct print_t<list_t<T1,T2>>
{
    typedef typename T1 result;
    static void print(){
        printf("\nelem::");
        result::print();
        print_t<T2>::print();
    }
};

//冒泡排序算法
template<typename T,template <typename,typenameclass CompareTstruct sort_t;
template<typename T,template <typename,typenameclass CompareT>
struct sort_t<list_t<T,null_t> ,CompareT>{
    typedef list_t<T,null_tsort_head;
    typedef T least_elem;
    typedef null_t remainder;
    typedef list_t<T,null_tresult;
};
template<typename T1,typename T2,template <typename,typenameclass CompareT>
struct sort_t<list_t<T1,T2>,CompareT>{
    template<bool _b_swapstruct swap_t{
        typedef list_t<T1,T2result;
    };
    template<> struct swap_t<false>{
        typedef list_t<typename T2::value,list_t<T1,typename T2::next> > result;
    };
    static const int order=!CompareT<T1,T2::value>::result;
    typedef typename swap_t<order>::result sort_head;//假如CompareT是less_t,将开头两个元素中大的放前面,小的放后面
    typedef typename sort_t<typename sort_head::next,CompareT>::least_elem least_elem;//假如CompareT是less_t,获取列表中最小的元素
    typedef list_t<typename sort_head::value,typename sort_t<typename sort_head::next,CompareT>::remainderremainder;//去掉末尾那个最小元素
    typedef list_t<least_elem,typename sort_t<remainder,CompareT>::resultresult;//将最小元素和剩余已经排好序的元素链表组成一个新链表
}; 
int main(int argccharargv[])
{
    typedef pair_t<50,6> e1_t;
    typedef pair_t<9,10> e2_t;
    typedef pair_t<1,2> e3_t;
    typedef pair_t<7,8> e4_t;
    typedef pair_t<3,4> e5_t;
    typedef pair_t<-6,4> e6_t;

    typedef list_t6(e1_t,e2_t,e3_t,e4_t,e5_t,e6_tdate_t;
    printf("原始数据:");
    print_t<date_t>::print();

    typedef sort_t<date_t,less_t>::result data_ta;
    printf("\n\n从小到大:");
    print_t<data_ta>::print();

    typedef sort_t<date_t,greate_t>::result data_tb;
    printf("\n\n从大到小:");
    print_t<data_tb>::print();
 
最后的输出:
原始数据:
elem::50 6
elem::9 10
elem::1 2
elem::7 8
elem::3 4
elem::-6 4
从小到大:
elem::-6 4
elem::1 2
elem::3 4
elem::7 8
elem::9 10
elem::50 6
从大到小:
elem::50 6
elem::9 10
elem::7 8
elem::3 4
elem::1 2
elem::-6 4

Feedback

# re: 使用元编程在编译期对数值进行排序  回复  更多评论   

2014-10-17 10:18 by hellmonky
很久没有看到博客更新了,从tinyscheme注释开始关注您,希望能看到更多相关的主题,非常感谢您的分享!

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理