欧美视频一区二区在线观看,久久国产一二区,欧美啪啪成人vr

[yc]伪typeof

shifan3 — Thu, 21 Dec 2006 06:29:00 GMT

发信�? shifan (学习��云技�?, 杉K��: C++
�?nbsp; �? 伪typeof
发信�? 飘�ؓ水云�?(Tue Dec 19 16:38:45 2006), 转信

1 /*
2 用标准C++实现typeof是不可能�?br> 3 �q�个是我写的一个approached typeof
4 所有需要被静态反��出来的�c�d��必须先用DECL_TYPE注册
5 模板如果仅仅带有1个参数可以用DECL_TEMPLATE_1注册
6 多个参数的模板还不支持。�?br> 7 主要是没惛_��~�码
8
9 ��d��能注�?4个类�?br>10 可以通过MAX_TYPE_NUMBER讄��
11
12 支持的模板嵌套层数大�U��ؓ32 �Q?nbsp;log2(MAX_TYPE_NUMBER)
13 MAX_TYPE_NUMBER必须�?的整�ơ数�q?br>14 */
15 namespace my_typeof
16 {
17
18   const int MAX_TYPE_NUMBER = 64;
19
20   template <int N>
21   struct dummy
22   {
23     int a[N];
24   };
25
26
27   template <int N, typename Arg1>
28   struct select_by_number_1;
29
30   template <int N>
31   struct select_by_number
32   {
33     typedef typename select_by_number_1<N % MAX_TYPE_NUMBER, typename
34 select_by_number<N / MAX_TYPE_NUMBER>::type>::type type;
35   };
36
37
38   template <typename T>
39   struct number_of
40   {
41     static const int v = sizeof(generic_f(*(T*)0)) / sizeof(int);
42   };
43
44
45 #define DECL_TYPE(T, N) \
46   namespace my_typeof{  \
47   template<>\
48   struct select_by_number<N> \
49   {\
50     typedef T type;\
51   };\
52   dummy <N> generic_f(const T&);}
53
54
55 #define DECL_TEMPLATE_1(T, N) \
56   namespace my_typeof{        \
57   template<typename Arg1>\
58   struct select_by_number_1<N, Arg1>\
59   {\
60     typedef T<Arg1> type;\
61   };\
62   template <typename Arg1>\
63   dummy<N + number_of<Arg1>::v * MAX_TYPE_NUMBER > generic_f(const T<Arg1>&);}
64
65
66
67 #define TYPE_OF(x) my_typeof::select_by_number
68 sizeof (int)>::type
69
70 }
71
72
73 //sample
74 #include <iostream>
75 #include <vector>
76 #include <list>
77
78
79 DECL_TYPE(int, 1);
80 DECL_TEMPLATE_1(std::vector, 2);
81 DECL_TEMPLATE_1(std::list, 3);
82 DECL_TYPE(double, 4)
83
84 using namespace std;
85 int main(int, char*[])
86 {
87   vector<list<vector<list<double> > > > v1;
88   TYPE_OF(v1) v2;
89   v1 = v2;
90   return 0;
91 }
92
93

--
You well 撒法�Q�You well all 撒法�Q?br>
�?内容修改:·shifan �?Dec 21 14:21:57 修改本文内容·[FROM: shifan]
�?来源:·飘�ؓ水云�?freecity.cn·[FROM: shifan]

shifan3 2006-12-21 14:29 发表评论

[yc]Multi Bit Mask

shifan3 — Thu, 26 Oct 2006 15:37:00 GMT

boost的integer/integer_mask.hpp仅仅做了单个位的bit mask
要多个位必须写很多遍high_bit_mask_t
使用low_bits_mask_t也不能完全解决问�?br>所以自��q��Typelist的��U�写法写了一�?/p>

用法举例
bit_mask::value�q�回一个��|��该值的�W?�?位被�|��ؓ1
其余位�ؓ0

  1
  2 namespace multi_bit_mask
  3 {
  4     namespace details
  5     {
  6
  7         template <typename T>
  8         struct get_size
  9         {
10             enum {size = sizeof(T)};
11         };
12
13         template <int Bit>
14         struct bit_storage
15         {
16             typedef typename bit_storage<Bit - 1>::storage_type storage_type;
17         };
18
19         //---------platform dependency-----------------------
20
21         typedef unsigned int smallest_storage_type;
22         typedef unsigned long long largest_storage_type;
23
24
25
26         template <>
27         struct bit_storage<0>
28         {
29             typedef smallest_storage_type storage_type;
30         };
31
32         template <>
33         struct bit_storage<get_size<smallest_storage_type>::size * 8>
34         {
35             typedef largest_storage_type storage_type;
36         };
37
38         //disable the 65th bit
39         template <>
40         struct bit_storage<get_size<largest_storage_type>::size * 8>
41         {
42             typedef void storage_type;
43         };
44
45         //---------end of platform dependency----------------
46
47
48         template <unsigned int N, typename Next>
49         struct int_list
50         {
51             typedef typename bit_storage<N>::storage_type storage_type;
52             static const storage_type value = N;
53             typedef Next next;
54         };
55
56         struct null_type{};
57
58         template<typename T1, typename T2, bool is_first>
59         struct selector
60         {
61             typedef T1 type;
62         };
63
64         template<typename T1, typename T2>
65         struct compare_type
66         {
67             const static bool is_larger = sizeof(T1) > sizeof(T2);
68             typedef typename selector<T1, T2, is_larger>::type large_type;
69             typedef typename selector<T1, T2, !is_larger>::type small_type;
70         };
71
72
73
74         template<typename T1, typename T2>
75         struct selector<T1, T2, false>
76         {
77             typedef T2 type;
78         };
79
80         template <typename List>
81         class find_largest_storage
82         {
83             typedef typename find_largest_storage<typename List::next>::storage_type T1;
84             typedef typename bit_storage<List::value>::storage_type T2;
85         public:
86             typedef typename compare_type<T1, T2>::large_type storage_type;
87         };
88
89         template <>
90         class find_largest_storage<null_type>
91         {
92         public:
93             typedef smallest_storage_type storage_type;
94         };
95
96
97     }
98
99
100
101
102
103     template <int N>
104     struct single_bit_mask
105     {
106         typedef typename details::bit_storage<N>::storage_type storage_type;
107         static const storage_type value
108             = static_cast<storage_type>(single_bit_mask<N - 1>::value) * 2;
109     };
110
111     template <>
112     struct single_bit_mask<0>
113     {
114         typedef details::bit_storage<0>::storage_type storage_type;
115         static const storage_type value = 1;
116     };
117
118
119     typedef details::null_type null_type;
120
121     template <int N, typename Next>
122     struct int_list_t : public details::int_list<N, Next> {};
123
124     template <typename List>
125     struct bit_mask
126     {
127     public:
128
129         typedef typename details::find_largest_storage<List>::storage_type storage_type;
130
131         static const storage_type value
132             = static_cast<storage_type>(single_bit_mask<List::value>::value)
133             | static_cast<storage_type>(bit_mask<typename List::next>::value);
134     };
135
136     template <>
137     struct bit_mask<null_type>
138     {
139         typedef details::bit_storage<0>::storage_type storage_type;
140         static const storage_type value = 0;
141     };
142
143
144
145
146
147     #define INT_LIST_1(n1) multi_bit_mask::int_list_t
148     #define INT_LIST_2(n1, n2) multi_bit_mask::int_list_t
149     #define INT_LIST_3(n1, n2, n3) multi_bit_mask::int_list_t
150     #define INT_LIST_4(n1, n2, n3, n4) multi_bit_mask::int_list_t
151     #define INT_LIST_5(n1, n2, n3, n4, n5) multi_bit_mask::int_list_t
152     #define INT_LIST_6(n1, n2, n3, n4, n5, n6) multi_bit_mask::int_list_t
153     #define INT_LIST_7(n1, n2, n3, n4, n5, n6, n7) multi_bit_mask::int_list_t
154     #define INT_LIST_8(n1, n2, n3, n4, n5, n6, n7, n8) multi_bit_mask::int_list_t
155
156 }
157
158
159

sample

#include < iostream >
#include " multi_bit_mask.h "
using namespace std;
int main()
{
    cout << multi_bit_mask::bit_mask < INT_LIST_1( 1 ) > ::value << endl;
    cout << multi_bit_mask::bit_mask < INT_LIST_5( 0 , 1 , 2 , 3 , 4 ) > ::value << endl;
    cout << multi_bit_mask::bit_mask < INT_LIST_7( 0 , 1 , 2 , 3 , 4 , 4 , 2 ) > ::value << endl;

shifan3 2006-10-26 23:37 发表评论

shifan3 — Thu, 27 Jul 2006 08:27:00 GMT

Xpressive是一个C++的正则表辑ּ�库，目前是Boost的候选库�?br>Xpressive和Boost.Regex的区别很大。首先，Xpressive是一个纯头文件的库，也是��_��在��用之前不需要预先编译。其�ơ，Xpressive支持�c�M��于Spirit的静态语义定义�?br>
我们先来看一个例子：

#include <iostream>
#include <boost/xpressive/xpressive.hpp>

using namespace boost::xpressive;

int main()
{
    std::string hello( "hello world!" );

    sregex rex = sregex::compile( "(\\w+) (\\w+)!" );
    smatch what;

    if( regex_match( hello, what, rex ) )
    {
        std::cout << what[0] << '\n'; // whole match
        std::cout << what[1] << '\n'; // first capture
        std::cout << what[2] << '\n'; // second capture
    }

    return 0;
}

�q�是使用Xpressive动态语义定义的例子�Q�其中sregex::compile函数�~�译一个表�C�正则文法的�Ԍ��q�返回一个正则对象sregex
使用regex_match来��用这个正则对象匹配一个串。结果储存在what�?br>其中what[0]�q�回整个�Ԍ��what[1]~what[n]�q�回文法中用于标记的部分(用小括号括�v来的部分)
最后将输出
     hello world!
     hello
     world

如果惛_��一个串中查扄��合该文法的子�Ԍ��可以使用regex_search�Q�用法和regex_match一��P��此外�q�可以用regex_replace来进行替换�?br>

静态文法：
Xpressive除了可以用compile来分析一个文法串之外�Q�还可以用类��g��Spirit的方式来静态的指定文法�Q?br>

sregex re = '$' >> +_d >> '.' >> _d >> _d;

�q�将定义一个表�C�金额的�Ԍ��其中_d表示一个数字，相当于串 $\d+.\d\d
�q�样定义文法��比之前的动态定义更加高效，�q�且�q�有一个附加的好处�Q?br>分��定义�Q?/p>

sregex re = '$' >> +_d >> '.' >> _d >> _d;
sregex s = '(' >> re >> ')';

�q�样s表示为用括号括�v来的re
通过分��定义�Q�文法能被表�C�的更加清楚�?br>更加��的是，分��定义�q�可以向后引用，因此能够分析EBNF

sregex group, factor, term, expression;
group       = '(' >> by_ref(expression) >> ')';
factor      = +_d | group;
term        = factor >> *(('*' >> factor) | ('/' >> factor));
expression  = term >> *(('+' >> term) | ('-' >> term));

expression定义了一个四则表辑ּ��Q�注意其中group的定义�?br>�q�里必须使用by_ref是因为Xpressive默认是值拷贝，如果�q�里使用默认的方式，那么会造成一个无限��@环�?br>

Xpressive可以在这里下�?br>http://boost-consulting.com/vault/index.php?PHPSESSID=f1d4af8b742cfa7adae7aab373cfc535&direction=0&order=&directory=Strings%20-%20Text%20Processing&PHPSESSID=f1d4af8b742cfa7adae7aab373cfc535
内有详细的文�?/p>

shifan3 2006-07-27 16:27 发表评论

[yc]乱序Policy手法

shifan3 — Sun, 23 Jul 2006 17:06:00 GMT

看了546@C++@Freecity之后�Q�发觉非常有意�?由此产生一些想�?/p>

很多时候写一个类的时候，需要多个模版参敎ͼ�例如一个遗传算法的��法�c�，需要一个模版参数来指定交配方式�Q�另一个模版参数来指定子代选择的方式，�q�要一个参数来指定变异的方式。那么一般来��_��q�个�c�M��写成�Q?/p>

template        , class CrossPolicy = AvgCrossPolicy                        //杂交方式
        , class SelectPolicy = DefaultSelectPolicy                //子代选择的方�?br>        , class VariationPolicy = ReverseVariationPolicy>        //变异方式
class Gene
        : private AvgCrossPolicy
        , private SelectPolicy
        , private VariationPolicy
{
        ....
};

�q�样用户要��用该�cȝ��时候，可以直接指定T�Q�就行了�Q�然而如果要指定变异方式�Q�那么就必须把所有的参数都显式的写出来，很不方便

546提供了一�U�有效的�Ҏ��Q�可以让我们仅仅指定变异参数�Q�而不用写出另两个Policy
甚至允许我们以�Q意的��序书写几个Policy参数�Q�都不会有问�?/p>

预备知识:
TypeList
一个TypeList是一个类型的容器
template
struct TypeList
{
typedef Type_ Type;
typedef Next_ Next;
};
�q�就是一个TypeList�?br>看这个写法，是不是像一个链表？
首先定义一个类型来表示链表��：class NullType{};
现在一个包含了2个类型的TypeList��可以写为：
TypeList >

如何在一个TypeList中查找一个类型的子类�Q?br>首先要有一个IsDerivedFrom
�q�个比较��?br>template
class IsDerivedFrom
{
        struct large{char a[2];};
        static char pred(Base*);
        static large pred(...);
public:
        enum {Is = sizeof(pred((T*)0)) == sizeof(char)};
};

然后FindChild��容易了
template
struct FindChild
{
        template
        struct Select
        {
                typedef typename List::Type Type;
        };

        template <>
        struct Select
        {
                typedef typename FindChild::Type Type;
        };

typedef typename Select >::Type Type;
};

当然�q�要对一些特�D�情况进行特化，例如NullType
template
struct FindChild
{
typedef NullType Type;
};
�q�里使用NullType来表明没扑ֈ�

实际操作�Q?br>首先需要给3个Policy3个基�c�，分别�?br>class AvgCrossPolicyBase{};
class SelectPolicyBase{};
class VariationPolicyBase{};
内容为空��p��了，�q�样也没有虚函数调用的开销

然后声明一个类来表�C�默认情况：
class DefaultPolicy{};

定义一个宏
#define TYPELIST_3_N(a, b, c) TypeList > >

下面要写一些选择�?用于把合适的�c�d��选择出来�Q�如果没扑ֈ��Q�则要��用默认的�c�d��
template
struct Selector
{
        template
        struct Judge
        {
                typedef RetType Type;
        };

        template<>
        struct Judge
        {
                typedef DefaultType Type;
        };
        typedef typename Judge::Type >::Type Type;
};

好啦�Q�现在整个类的声明可以写�?/p>

template        , class CrossPolicy_ = DefaultPolicy
        , class SelectPolicy_ = DefaultPolicy
        , class VariationPolicy_ = DefaultPolicy     //其后的参数用户不可指�?br>        , class List = TYPELIST_3_N(CrossPolicy_, SelectPolicy_, VariationPolicy_)
        , class CrossPolicy = typename Selector::Type
        , class SelectPolicy = typename Selector::Type
        , class VariationPolicy = typename Selector::Type
        >
class Gene
        : private CrossPolicy
        , private SelectPolicy
        , private VariationPolicy
{

        ....
};

其中�W?-7个参敎ͼ�List�Q�CrossPolicy�Q�SelectPolicy和VariationPolicy�Q�是不由用户指定的，仅仅是�ؓ了�v一个别�?br>�W�一个参数T必须指定�Q�然�?�Q?�Q?�q?个参数就可以��L��的改变顺序了
例如�Q�可以写Gene而不会有��M��问题
如果不想要最后面几个参数的话也行�Q�但是代码就要稍微长一�?br>而且最好在�c�里面进�?个typedef
typedef typename Selector::Type CrossPolicy;
�{�，以便在实现的时候��?/p>

shifan3 2006-07-24 01:06 发表评论

[yc]自己实现Lambda�Q�第二部分）

shifan3 — Sat, 15 Jul 2006 07:32:00 GMT

摘要: 发信�? shifan (家没有豚�?T.T), 杉K��: C++�?nbsp; �? 如何实现Lambda[�W�二部分]发信�? 飘�ؓ水云�?(Thu Jun 8 23:30:20 2006), 转信章节:�?�W�一部分的小�l�九:��?如何减少Lambda代码的冗余和依赖性十:bind的实现十一:实现phoenix 八．中期�ȝ��目前的结果是�q�样�?.. 阅读全文

shifan3 2006-07-15 15:32 发表评论

[yc]自己实现Lambda

shifan3 — Fri, 09 Jun 2006 05:23:00 GMT

摘要: 一�Q?nbsp;什么是Lambda所谓Lambda�Q�简单的说就是快速的��函数生成。在C++中，STL的很多算法都要求使用者提供一个函数对象。例如for_each函数�Q�会要求用户提供一个表�?#8220;行�ؓ”的函数对象。以vector��Z��Q�如果想使用for_each对其中的各元素全部赋��gؓtrue�Q�一般需要这么一个函数对象， c... 阅读全文

shifan3 2006-06-09 13:23 发表评论

shifan3 — Sun, 18 Dec 2005 04:02:00 GMT

    最�q��ؓ了解析SQL语法�Q�怀着试一试的心态去��M��boost的spirit库，因�ؓ该库的文��的��介里写着LL parser framework represents parsers directly as EBNF grammars in inlined C++。看着framework�q�个词自然觉得这个库很牛B�Q�试用了一下果然如此�?br>    所谓EBNF��x��展巴克斯范式�Q�是一�U�描�q�Context-Free Language的文法。在目前常见的非自然语言中，大部分都可以用EBNF表示。例如：
      group  ::='('exp ')'
      factor ::=integer| group
      term   ::=factor(('*'factor)|('/'factor ))*
      exp    ::=term(('+'term)|('-'term ))*
�q�是一个整数表辑ּ�的EBNF。该�D�|��q�用spirit在C++中的实现则是�Q?br>

   rule<> group, factor, term, exp;
   group  = '(' >> exp >> ')';
   factor = int_p | group;
   term   = factor >> *(('*' >> factor) | ('/' >> factor));
   exp    = term >> *(('+' >> term) | ('-' >> term));

�q�里使用=代替::=, �?gt;>代替�I�格�q�接。�ƈ且由于C++语法所限，EBNF中后�|�的*在spirit中改为前�|��?br>�{�式左边的单词被�U�Cؓ一个rule�Q�等式右边�ؓrule的定义。我们可以看��Z��个group是一个exp加上一�Ҏ��P��一个factor是一个整数或者一个group,一个term是一个或多个factor�?/�q�接�Q�一个exp是一个或多个term�?-�q�接。处于最��端的exp可以据此识别��Z��下表辑ּ�

   12345
   -12345
   +12345
   1 + 2
   1 * 2
   1/2 + 3/4
   1 + 2 + 3 + 4
   1 * 2 * 3 * 4
   (1 + 2) * (3 + 4)
   (-1 + 2) * (3 + -4)
   1 + ((6 * 200) - 20) / 6
   (1 + (2 + (3 + (4 + 5))))

得到一个rule之后�Q�我们就可以�?/font> parse函数对一个串�q�行识别了。例�?br>

parse( " (1 + (2 + (3 + (4 + 5)))) " , exp);

该函数返回一个结构parse_info�Q�可以通过讉K��其中的full成员来判断是否成功识别，也可以访问stop成员来获知失败的位置。这里要特别提一点，关于各个�W�号之间的空��|��spirit的文档的正文说的是给parse再传一个参数space_p�Q�通知parse跌��所有的�I�格�Q�然而在FAQ中又提到�Q�如果��用以上方法定义rule�Q�第三个参数传space_p会失败。原因是使用rule默认定义的规则被�U�Cؓcharacter level parsing�Q�即字符�U�别解析�Q�而parse的第3个参��C��适用于phrase level parsing�Q�即语法�U�别解析。要使用�W?个参数可以有几种�Ҏ��?br> 1。在parse的第二个参数直接传入一个EBNF表达式，不创建rule对象�?br>

parse( " hello world " , * anychar_p, space_p);

2。以rule创徏rule�?br>

rule < phrase_scanner_t > exp;

注意虽然可以用这两个办法屏蔽�I�格�Q�但是这样可能完全改变EBNF文法的语义，��其是在语言本��n需要识别空格的时候。对于这�U�情况，可以不��用第三个参数�Q��ƈ在需要出现空格的地方加上space_p,或�?space_p�?space_p�Q�其�?�?分别表示后面的符可��l�出��C��ơ以上和0�ơ以上。例如一个以�I�格分隔的整数列表可以写成int_p >> *(+space_p >> int_p)
如上使用parse可以识别一个串�Q�但�q�不能做更多的操作，例如��语法里的各个成分提取出来。对于这��L��需求，可以通过actor实现。下面是使用actor的一个简单例�?br>

   bool
   parse_numbers(char const* str, vector<double>& v)
   {
      return parse(str,

   //  Begin grammar
      (
         real_p[push_back_a(v)] >> *(',' >> real_p[push_back_a(v)])
      )
      ,
      //  End grammar
      space_p).full;
   }

注意�?span class=identifier>real_p后面的[]�Q�中括号里面是一个仿函数�Q�函数指针或者函数对象）�Q�该仿函数具有如下调用型�?br>

   void operator()(IterT first, IterT last) const;
   void operator()(NumT val) const;
   void operator()(CharT ch) const;

一旦spase发现了匹�?span class=identifier>real_p的子�Ԍ��׃��调用该functor。不同的rule可能会对应不同的调用型别�?/span>
�W�一个型别针对一般规则，first和last��Z��个指向字�W�的�q�代器（一般�ؓchar*�Q?匚w��的子串�ؓ[first, last)
�W�二个型别针�Ҏ��字型规则�Q�如real_p和int_p, 参数val是一个数字类型�?br>�W�三个性别针对单字�W�型规则�Q�如space_p, 参数ch是一个字�W�类型�?br>real_p[push_back_a(v)]中的push_back_a是一个spirit已经定义好的functor�Q�它会将匚w��好的内容依照匚w��到的旉��序调用v的push_back函数加入到v中�?br>
到此spirit的常用功能就都介�l�完了。要详细深入了解可以参考spirit的文档�?br>
最后在题一个注意要炏V��spirit的各�U�EBNF�q�接都是指针�q�接�Q�因此才能在expression被赋值前��在group的定义里面��用。所以在使用EBNF的时候一定要��心不要��局部变量的rule提供�l�全局或者类成员变量使用�Q�例如：

   class A
   {
      rule<> s;
      A()
      {
         rule<> r = int_p | hex_p;

         s = r >> *(+space_p >> r); //error, r destructed after return
      }
   };

如果真想使用局部作用域�Q�可以在局部的rule前面加上static.

shifan3 2005-12-18 12:02 发表评论