溪流软件工作室

山寨一个 Boost.Bind

溪流 — Sat, 21 Apr 2012 07:01:00 +0000

一直比较好奇 boost::bind 里面占位符和参数的顺序是怎么实现的，也一直看不太懂这方面源代码，昨晚好好看了下，终于有点弄懂了。小记一笔，与大家分享。

先看一个简单的用例：

#include <boost/bind.hpp>

int foo(bool a, int b, double c)

{

return 0;

}

int main()

{

boost::bind(foo, _2, 2, _1)(3.0, true); // foo(true, 2, 3.0)

return 0;

}

这里有两个步骤，第一步是绑定过程，第二步是调用。

绑定过程给出了 boost::bind 所需要的几乎所有信息——只有两个参数——_1 和 _2——的类型和值，有待确定。但是他们的顺序是确定了的，类型实际上也由函数签名所限制。bind 是一个函数，返回一个 bind_t 类型的对象，bind_t 是一个仿函数。

三个参数时 bind_t 应具备的参数信息：

参数1	参数2	参数3
占位符2	绑定值	占位符1

调用的时候给出的参数表只有两个：

参数1	参数2
值1	值2

调用时的参数匹配过程如下：

我们暂且把第二列中的参数表称为 BindList，第三列的参数表称为 CallList。BindList 和 CallList 都需要保存参数，这部分公用的东西先简单实现如下：

struct BindArguments0

{

};

template <typename A1>

struct BindArguments1 : public BindArguments0

{

BindArguments1(A1 a1) : a1(a1)

{

}

A1 a1;

};

template <typename A1, typename A2>

struct BindArguments2 : public BindArguments1<A1>

{

BindArguments2(A1 a1, A2 a2) : BindArguments1(a1), a2(a2)

{

}

A2 a2;

};

template <typename A1, typename A2, typename A3>

struct BindArguments3 : public BindArguments2<A1, A2>

{

BindArguments3(A1 a1, A2 a2, A3 a3) : BindArguments2(a1, a2), a3(a3)

{

}

A3 a3;

};

为了简洁和突出关键，我们暂时只实现到 3 个参数。从上面的代码看，多一个参数，代码是线性增长的，不是指数级增长的，所以很容易（人工地）扩充到所需要的参数个数。如果需要玩些花样，可以使用宏循环技巧自动生成代码，这部分东西在《C++ 下 Function 对象的实现（下）》中已经谈到过，本文不再赘述。

接下来实现 CallList0 到 CallList3，它除了存储参数，还具备用占位符查询出实际值的能力。占位符实现如下：

static struct PlaceHolder1

{

} _1;

static struct PlaceHolder2

{

} _2;

static struct PlaceHolder3

{

} _3;

对，就这么简单粗暴就可以了。网上有些文章说使用 int to type，那也可以，做成这样：

template <int i>

struct PlaceHolder

{

};

static PlaceHolder<1> _1;

static PlaceHolder<2> _2;

static PlaceHolder<3> _3;

但关键点不在这里。我们只要能对各种占位符区分类型就可以了。下文以第一个简单的定义为准。

CallList 这样子定义（灰色的先假装没看见）：

class CallList0 : public BindArguments0

{

public:

CallList0()

{

}

public:

template <typename T>

T operator [](T t)

{

return t;

}

};

template <typename A1>

class CallList1 : public BindArguments1<A1>

{

public:

CallList1(A1 a1) : BindArguments1<A1>(a1)

{

}

public:

A1 operator [](PlaceHolder1)

{

return a1;

}

template <typename T>

T operator [](T t)

{

return t;

}

};

template <typename A1, typename A2>

class CallList2 : public BindArguments2<A1, A2>

{

public:

CallList2(A1 a1, A2 a2) : BindArguments2<A1, A2>(a1, a2)

{

}

public:

A1 operator [](PlaceHolder1)

{

return a1;

}

A2 operator [](PlaceHolder2)

{

return a2;

}

template <typename T>

T operator [](T t)

{

return t;

}

};

template <typename A1, typename A2, typename A3>

class CallList3: public BindArguments3<A1, A2, A3>

{

public:

CallList3(A1 a1, A2 a2, A3 a3) : BindArguments3(a1, a2, a3)

{

}

public:

A1 operator [](PlaceHolder1)

{

return a1;

}

A2 operator [](PlaceHolder2)

{

return a2;

}

A3 operator [](PlaceHolder3)

{

return a3;

}

template <typename T>

T operator [](T t)

{

return t;

}

};

存储已经由 BindArguments 负责了，CallList 实现了 operator[] 用于从 PlaceHolderN 查询调用时的参数 aN。

还有一个问题，CallList 中的参数个数往往会比 BindList 中的少（其中某几个已经用实际值绑定了），这样，从 BindList 到 CallList 查询的时候，需要判断哪些是 PlaceHolder，哪些是实际参数，这就不太好操作了。为了到时候统一写法，我们让 CallList 不仅支持使用 PlaceHolder 查询，也支持使用实际参数值来查询。增加上面灰色代码，使用实际参数查询的时候，直接返回那个值。

CallList 就到此为止。现在开始实现 BindList。跟 CallList 一样，每个 BindList 都继承 BindArguments。……似乎这样就完事了？BindList 貌似没其他事情好做了。。。不过，BindList 里面保存了最原始的参数个数信息，如果我们不对函数进行萃取的话，参数个数只能从这里获取，因此调用过程只能写在这里——貌似还没说清楚，不要紧，这是后话。暂且把相关代码变灰，等下就可以看到原委了。

class BindList0 : public BindArguments0

{

public:

BindList0()

{

}

public:

template <typename F, typename A>

void operator ()(F f, A a)

{

f();

}

};

template <typename A1>

class BindList1 : public BindArguments1<A1>

{

public:

BindList1(A1 a1) : BindArguments1<A1>(a1)

{

}

public:

template <typename F, typename A>

void operator ()(F f, A a)

{

f(a[a1]);

}

};

template <typename A1, typename A2>

class BindList2 : public BindArguments2<A1, A2>

{

public:

BindList2(A1 a1, A2 a2) : BindArguments2<A1, A2>(a1, a2)

{

}

public:

template <typename F, typename A>

void operator ()(F f, A a)

{

f(a[a1], a[a2]);

}

};

template <typename A1, typename A2, typename A3>

class BindList3: public BindArguments3<A1, A2, A3>

{

public:

BindList3(A1 a1, A2 a2, A3 a3) : BindArguments3(a1, a2, a3)

{

}

public:

template <typename F, typename A>

void operator ()(F f, A a)

{

f(a[a1], a[a2], a[a3]);

}

};

快到最后一步了。我们现在可以来考虑 Bind 的最终形式了——模版类？模板函数？从使用上来说，模版类在用的时候必须给出模版参数，想象一下这样的写法：

bind<int (bool, int, double), PlaceHolder2, int, PlaceHolder1>(foo, _2, 2, _1)）

……太没有易用性了。而模版函数不用，boost::bind 也实现成了一组模板函数。同时，函数 Bind 返回的东西必须是可执行体，而且要包含一个BindList，C++ 里面只有仿函数能做到。这个结构我们定义为 BindT。先看代码：

template <typename F, typename BL>

class BindT

{

public:

BindT(F f, BL bl) : f(f), bl(bl)

{

}

public:

void operator ()()

{

bl(f, CallList0());

}

template <typename A1>

void operator ()(A1 a1)

{

bl(f, CallList1<A1>(a1));

}

template <typename A1, typename A2>

void operator ()(A1 a1, A2 a2)

{

bl(f, CallList2<A1, A2>(a1, a2));

}

template <typename A1, typename A2, typename A3>

void operator ()(A1 a1, A2 a2, A3 a3)

{

bl(f, CallList3<A1, A2, A3>(a1, a2, a3));

}

private:

F f;

BL bl;

};

BindT 保存了函数 f 以及 BindList bl。我们找一个 operator()(A1 a1) 来看，里面写成了 bl(f, CallList1<A1>(a1));，这得益于 BindList 里面实现了 operator()()。

按通常理解，可能会写成这样：

CallList1<A1> cl(a1);

f(cl[bl.a1], cl[bl.a2], ……) 等等，bl 里面到底有几个元素？这就不知道了，因为 BindT 接受的只是一个 BindList，所以需要 BindList 给出执行形式。因此，上面 BindList 需要灰色部分的 operator()() 代码。（当然，也可以换种实现方法，抛弃 BindList，在 BindT 中将参数散开来，这看上去也是可行的。）

最后，给出一组 Bind 模版函数，作为最终使用接口：

template <typename F>

BindT<F, BindList0> Bind(F f)

{

return BindT<F, BindList0>(f, BindList0());

}

template <typename F, typename T1>

BindT<F, BindList1<T1>> Bind(F f, T1 t1)

{

return BindT<F, BindList1<T1>>(f, BindList1<T1>(t1));

}

template <typename F, typename T1, typename T2>

BindT<F, BindList2<T1, T2>> Bind(F f, T1 t1, T2 t2)

{

return BindT<F, BindList2<T1, T2>>(f, BindList2<T1, T2>(t1, t2));

}

template <typename F, typename T1, typename T2, typename T3>

BindT<F, BindList3<T1, T2, T3>> Bind(F f, T1 t1, T2 t2, T3 t3)

{

return BindT<F, BindList3<T1, T2, T3>>(f, BindList3<T1, T2, T3>(t1, t2, t3));

}

好了，简单实现到此为止。我们这里只是注重了参数表如何存储，如何使用占位符更改顺序，对于其他问题则没有做过多考虑。还有诸如 const/非const、有返回值/无返回值，引用/非引用、函数指针/成员函数/仿函数等问题都没有涉及。以上代码仅仅支持普通函数和仿函数，不支持成员函数。

做个简单的测试：

int foo0()

{

return 0;

}

int foo1(int a)

{

return 0;

}

int foo2(int a, int b)

{

return 0;

}

int foo3(int a, int b, int c)

{

return 0;

}

int main()

{

Bind(foo0)();

Bind(foo1, _1)(1);

Bind(foo1, 2)();

Bind(foo2, _1, _2)(1, 2);

Bind(foo2, _2, _1)(1, 2);

Bind(foo2, _1, 1)(2);

Bind(foo2, 1, _1)(2);

Bind(foo2, 1, 2)();

Bind(foo3, _1, _2, _3)(1, 2, 3);

Bind(foo3, _1, _3, _2)(1, 2, 3);

Bind(foo3, _2, _1, _3)(1, 2, 3);

Bind(foo3, _2, _3, _1)(1, 2, 3);

Bind(foo3, _3, _1, _2)(1, 2, 3);

Bind(foo3, _3, _2, _1)(1, 2, 3);

Bind(foo3, _1, _2, 3)(1, 2);

Bind(foo3, _2, _1, 3)(1, 2);

Bind(foo3, _1, 2, 3)(1);

return 0;

}

将以上代码合起来（去除开头第一段代码和中间一个 PlaceHolder<N>的代码），就是可运行的程序了。（VS2010通过）

示例程序中的各个结构与 boost::bind 实际代码的对应关系如下：

示例代码	boost
Bind	bind
BindT	_bi::bind_t
BindListN	listN
CallListN	listN
BindArgumentsN	storageN
PlaceHolderN	arg<N>

BindList 和 CallList 在 boost::bind 的实现中是合并的，这是阅读时的很大干扰源。所以刚才把他们拆了讲，但愿能写明白些。

好久没发了，请各位指教。

C++ 的几种 cast 运算符到底是什么？与 C 风格的类型转换 (T)value 有什么区别和联系？

溪流 — Fri, 23 Mar 2012 01:53:00 +0000

网上的文章但凡有提到 static_cast、const_cast、reinterpret_cast、dynamic_cast 的，都会语重心长的说，他们克服了 C 风格的类型转换的缺点，应当使用它们。

可是，C 风格的到底有什么坏处？C++的这些 cast 又有什么好处呢？

昨天以前，我连这些 cast 是什么都不知道（很惭愧）。昨天因为同事们提到这件事，于是小小研究了一下。一些实验代码如下：

1、无继承的类型转换

class A

{

};

class B

{

public:

operator A()

{

return A();

}

};

int main()

{

B b;

A a = (A)b; // 执行 operator A()

A a2 = static_cast<A>(b); // 执行 operator A()

A a3 = dynamic_cast<A>(b); // 不允许

A a4 = reinterpret_cast<A>(b); // 不允许

A a5 = const_cast<A>(b); // 不允许

return 0;

}

2、const_cast

struct A

{

int m;

A(int m = 0) : m(m)

{

}

};

int main()

{

const A a;

A a2 = (A)a; // 允许，(A) 有没有都一样，a2 是个新变量

a2.m = 1; // a2 的改变不影响 a

A &a3 = (A &)a; // 允许

a3.m = 2; // 影响 a

// A &a4 = a; // 不允许，const 限定起作用了

A *pa5 = (A *)&a; // 允许

pa5->m = 3; // 影响 a

// A *pa6 = &a; // 不允许，const 限定起作用了

// A aa2 = const_cast<A>(a); // 不允许

A &aa3 = const_cast<A &>(a); // 允许

aa3.m = 2; // 影响 a

A *paa5 = const_cast<A *>(&a); // 允许

paa5->m = 3; // 影响 a

const int i = 0;

const int &i2 = i;

const int *pi3 = &i;

// int j = const_cast<int>(i); // 不允许

int &j2 = const_cast<int &>(i2); // 允许

int *pj3 = const_cast<int *>(pi3); // 允许

return 0;

}

从第1点的试验，加上外界资料的说明，看上去const_case 只允许具有不同cv限定符的同类型之间的转换。

值得注意的是，如果类型A不是指针或引用，不能使用const_cast（使用了也无意义，见 A a2 = (A)a 这一行）

在 const_cast 可以使用的情形，(T)value 形式都可以使用，(T)value 在功能上完全覆盖 const_cast。

2、reinterpret_cast

class A

{

public:

operator int *()

{

return nullptr;

}

};

int main()

{

int i = 0;

double d = 1.0;

int *p = nullptr;

// int di = reinterpret_cast<int>(d); // 不允许

int pi = reinterpret_cast<int>(p); // 允许

// int pi2 = static_cast<int>(p); // 不允许

// double id = reinterpret_cast<double>(i);// 不允许

// double pd = reinterpret_cast<double>(p);// 不允许

int *ip = reinterpret_cast<int *>(i); // 允许

// int *ip2 = static_cast<int *>(i); // 不允许

// int *dp = reinterpret_cast<int *>(d); // 不允许

A a;

int *pa = (int *)a; // 允许

int *pa2 = static_cast<int *>(a); // 允许

// int *p2 = reinterpret_cast<int *>(a); // 不允许

return 0;

}

看上去，reinterpret_cast 可以理解为在指针和数值之间转换的一种方式，无关任何运算符重载，仅仅把指针转为字面值，或者把数字转为指针，转换的过程中值没有任何改变，只是告诉编译器不要报类型不匹配而已。

另外，在reinterpret_cast可以使用的情形，static_cast 是不可以使用的，除非定义了相应的类型转换运算符。

在 reinterpret_cast 可以使用的情形，(T)value 的方式同样可以完全胜任，(T)value 在功能上完全覆盖 reinterpret_cast。

dynamic_cast 我自认为还是理解的，就不试了。

综上，我的理解如下：

1、static_cast + const_cast + reinterpret_cast = (T)value

C++ 把原来C风格的的这三个cast拆分成了三个，三者相互正交。大多数情况下，应该是 static_cast 在取代着 (T)value；只是在去除 cv 限定符的时候，换用 const_cast；在取指针字面值的时候，换用 reinterpret_cast。类型转换运算符 operator T() 由 static_cast 负责执行。

2、dynamic_cast 是 C++ 新增的，用于多态的情形，且只允许转换具有多态关系的继承树上的类型的指针和引用，不允许转换类型本身。它不是针对 (T)value而出现的，两者没有任何竞争关系，只是取决于不同的需求。

（不知这样理解是否正确，请批评指正~）

至于网上推崇用新写法，是不是为了更细化而容易理解？有没有什么是 (T)value 做不到而 *_cast 能做到的？或者反过来？

翻译一节 C++03 标准文档（3.10 左值和右值），请批评指正~

溪流 — Wed, 29 Feb 2012 14:50:00 +0000

3.10 Lvalues and rvalues [basic.lval]

左值和右值

1 Every expression is either an lvalue or an rvalue.

表达式不是左值就是右值。

2 An lvalue refers to an object or function. Some rvalue expressions—those of class or cv-qualified class type—also refer to objects. 47)

左值是指一个对象或者函数。某些右值（那些带或不带cv限定符的类类型）也是对象。

3 [Note:
some built-in operators and function calls yield lvalues. [Example: if E is an expression of pointer type, then *E is an lvalue expression referring to the object or function to which E points. As another example, the function
int& f();
yields an lvalue, so the call f() is an lvalue expression. ] ]

[注意：某些内置运算符以及一些函数调用会返回左值。[例1：如果 E 是一个指针类型的表达式，那么 *E 是一个左值表达式，指示指针 E 所指向的那个对象或者函数。例2：函数
int& f();
返回左值，所以函数调用 f() 是一个左值表达式。] ]

4 [Note: some built-in operators expect lvalue operands. [Example: built-in assignment operators all expect their left hand operands to be lvalues. ] Other built-in operators yield rvalues, and some expect them. [Example: the unary and binary + operators expect rvalue arguments and yield rvalue results. ] The discussion of each built-in operator in clause 5 indicates whether it expects lvalue operands and whether it yields an lvalue. ]

[注意：某些内置运算符需要左值操作数。[例：所有内置的赋值运算符的左操作数都必须是左值。] 有些内置运算符会返回右值结果，有些会需要右值操作数。[例：一元运算符“+”和二元运算符“+”都需要右值操作数，并且返回右值结果。] 我们在条款 5 中会对所有内置运算符进行讨论，指出它们的操作数和返回结果是左值还是右值。]

5 The result of calling a function that does not return a reference is an rvalue. User defined operators are functions, and whether such operators expect or yield lvalues is determined by their parameter and return
types.

调用返回值为非引用类型的函数，结果是右值。用户自定义的运算符也是函数，这些运算符的操作数以及结果是左值还是右值，取决于（运算符重载）函数的参数和返回值类型。

6 An expression which holds a temporary object resulting from a cast to a nonreference type is an rvalue (this includes the explicit creation of an object using functional notation (5.2.3)).

对非引用类型的转换表达式（包括使用函数式的记号进行显示创建）是右值，它将返回一个临时对象。

__________________
47) Expressions such as invocations of constructors and of functions that return a class type refer to objects, and the implementation can invoke a member function upon such objects, but the expressions are not lvalues.

有些表达式，比如调用构造函数的表达式，以及调用返回类类型的函数的表达式，它们也是对象，且可以对它们调用成员函数，但这种表达式不是左值。

____________________________________华丽的分页符____________________________________

7 Whenever an lvalue appears in a context where an rvalue is expected, the lvalue is converted to an rvalue; see 4.1, 4.2, and 4.3.

如果在一个需要右值的场合出现了左值，这个左值将被转换成右值。
见 4.1、4.2、4.3。

8 The discussion of reference initialization in 8.5.3 and of temporaries in 12.2 indicates the behavior of lvalues and rvalues in other significant contexts.

12.2 中关于引用的初始化和关于临时对象的讨论，也指出了左右值在其他重要场合的行为。

9 Class rvalues can have cv-qualified types; non-class rvalues always have cv-unqualified types. Rvalues shall always have complete types or the void type; in addition to these types, lvalues can also have incomplete types.

类类型的右值可以具有 cv 限定符；非类类型的右值不能被 cv 限定符修饰。右值通常是完整类型或者 void 类型，而对于左值来说，除了完整类型和 void 类型外，还可以是不完整类型。

10 An lvalue for an object is necessary in order to modify the object except that an rvalue of class type can also be used to modify its referent under certain circumstances. [Example: a member function called for an object (9.3) can modify the object. ]

通常情况下，如果要修改一个对象，它必须是左值。但在某些特定的场合，右值形式的类对象也可以被修改。[例：调用一个对象的成员函数（9.3），可以修改对象本身。]

11 Functions cannot be modified, but pointers to functions can be modifiable.

函数（对象）不能（在运行时）被修改，但是函数指针可以。

12 A pointer to an incomplete type can be modifiable. At some point in the program when the pointed to type is complete, the object at which the pointer points can also be modified.

指向一个不完整类型的指针可能是可修改的。当这个被指向的类型某时某刻成为完整类型后，这个指针所指向的那个对象也是可修改的。

13 The referent of a const-qualified expression shall not be modified (through that expression), except that if it is of class type and has a mutable component, that component can be modified (7.1.5.1).

被 const 限定的表达式所对应的对象不能（通过该表达式）被修改；除非这个对象是类类型并且含有 mutable 成员，此时该 mutable 成员可以被修改。

14 If an expression can be used to modify the object to which it refers, the expression is called modifiable. A program that attempts to modify an object through a nonmodifiable lvalue or rvalue expression is illformed.

如果一个表达式可以被用来修改此表达式对应的对象，那么这个表达式被称为可修改的。企图通过一个不可修改的左值者右值表达式去修改一个对象，是非法的。

15 If a program attempts to access the stored value of an object through an lvalue of other than one of the following types the behavior is undefined 48):
— the dynamic type of the object,
— a cv-qualified version of the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type of
the object,
— an aggregate or union type that includes one of the aforementioned types among its members (including,
recursively, a member of a subaggregate or contained union),
— a type that is a (possibly cv-qualified) base class type of the dynamic type of the object,
— a char or unsigned char type.

如果程序通过下列类型之外类型的左值访问一个对象的值，其行为是未定义的：

——对象的动态类型；
——CV 限定的对象动态类型；
——对象的动态类型对应的有符号或无符号类型；
——CV 限定的对象动态类型有符号或无符号类型；
——一个成员中含有聚合或者联合类型的聚合或者联合类型（包括递归形式的定义以及成员中有子聚合类型或者包含一个联合）
——对象的动态类型的基类类型（可以被 cv 限定符修饰）
——char 或 unsigned char 类型

__________________
48) The intent of this list is to specify those circumstances in which an object may or may not be aliased.
给出这份列表的目的是指明一些特定情形，在这些情形下对象可能被重叠，但也有可能不是，我们无法预知。

____________________________________华丽的分隔符____________________________________

以上，求指正，包括理解误区和语言组织不合理的，欢迎指出~ ^_^

溪流 WarKey 3.0 正式版已发布

溪流 — Sun, 05 Feb 2012 08:25:15 +0000

如题，这个版本与 3.0 beta2 差别不大。所有需要介入魔兽进程的功能还是没有加上，后续版本再说吧。

发个溪流 WarKey 3.0 beta2

溪流 — Fri, 06 Jan 2012 16:15:03 +0000

这个版本把界面重新整理了一下，停用了beta1所用的WTL，使用了自己的GUI框架，同时也使用了xlLib。开发工具上换成了 VS2010，之前为了小巧和MFC而使用VC6，写起来太不爽了，直接导致开发热情降低。脚本支持上，lua5.1换成了5.2，lua本身的升级变化还是有一点的，比如访问全局表的方式变了，等等。脚本格式定义还是基本上使用了原来beta1里的，有个NameSpace换成了新的URL，直接指向API说明页面。脚本的参数配置名字，beta1里面是0、1、2之类的数字，并且不允许重命名，现在改成了字符串，可以任意修改。软件核心功能上，相比3.1，把方案分组和组合键去掉了。方案分组看上去太麻烦了，而组合键，则是技术上做不到太好的用户体验。这么说吧，比如，用户想把按下 Ctrl+A 模拟成按下 B，那么，找到 Ctrl+A 的触发点没问题，但是之后要按下 B 的时候，一般 Ctrl 键没那么快放掉的，于是这个 B 就变成 Ctrl+B 了。主要原因就是这个场景，我举的例子还是最简单的情况，再复杂点，就更不好搞了。所以，在找到有效的技术方案前，这个功能先不搞。大概就这些，终于把 xlLib 全面用上了，感觉好爽。软件下载地址见导航栏链接

还是搞个独立博客玩吧

溪流 — Fri, 25 Nov 2011 17:43:10 +0000

一年前在 bluehost 的 wp 数据库好像是忘了备份回来，所以以前的文章都没有了，有点点可惜了。不过还好数量不大。原来的首页就不用了，维护太麻烦，直接把 WP 当首页了。下载溪流 WarKey 的同学请从左边或者上面的链接进入。软件好久没更新了，近期开始重新运作。 [ad#ad-1]

如果要拟定一份代码规范，哪些内容应该列入？

溪流 — Tue, 12 Jul 2011 22:22:00 +0000

如题，大致看了下网上能找到的一些规范，觉得大体有这么三个方面吧，一个是排版方面的，一个是命名方面的，一个是书写逻辑方面的。

排版方面的大概有，如何缩进，如何使用空格、换行，等等。命名方面的包括变量、函数、类、文件的取名等等。书写逻辑方面的就比较多了，可能包括：
是否全面使用异常、出错处理资源清理如何组织、如何利用编译提示防止常见错误……

一时间列不全。网上常见的文档我会参考的。除此之外，想从大家这里征求下，以上几个大方面之外，还有没有比较重要的方面？大家日常工作中有没有遇到一些特别希望别人也使用和自己一样的方式做的事？以及，哪些规定比较容易被推动？哪些规定不容易被推动？如果有一个规则强加在你头上，你会有怎样的心理？等等……

如果您有想法，请回复下，我们讨论讨论^_^

----------

顺便再问个问题，Windows 上的开发，大家喜欢动态链接 CRT（/MD、/MDd）还是静态链接 CRT（/MT、/MTd）？为什么？个人倾向于哪种？在公司里又是怎样做的？

如何写执行耗时任务的、可随时立即退出的函数呢？

溪流 — Thu, 26 May 2011 00:36:00 +0000

如题。

稍微解释下，因为有可能有人会误会：放新线程里面去不就可以了？这没有解决问题。如此的话，你那个线程函数怎么写？或者线程函数里调用的某个任务函数怎么写？总之，多线程虽然总是出现在这些问题的解决方案中，但不是多线程解决了这个问题。嗯……不知道说清楚了没？

目前我心里的答案只有这一种模式：

bool DoTask(HANDLE hQuitSignal)
{
    while (!QuitCondition)
    {
        if (WaitForSingleObject(hQuitSignal, 0) == WAIT_OBJECT_0)
        {
            return false;
        }

// Do something
}

return true;
}

其中，“// Do something”部分要细化到瞬间执行完成的细度。

但是我很困惑的是，如果这些任务很繁重，难道我必须每进行一些操作就 if (WaitForSingleObject(hQuitSignal, 0) == WAIT_OBJECT_0) 检查下吗？这样岂不是这种检测代码充斥在任务中了？

不知各位有何经验和体会，求教~

一个简单的 Tuple 实现

溪流 — Thu, 28 Apr 2011 22:05:00 +0000

标题中说的 Tuple 是指类似 boost::tuple 这样的设施。

很多时候我们需要返回/传入一堆参数，所以不得不每次定义一些为了数据传输的结构。Tuple 就是用来解决这一问题的，它提供即时构造一个这样的结构体的功能。而所付出的代价是，丧失各个成员的明确含义，只留下成员的序号。

两个元素的 Tuple 就是 Pair，如 std::pair。下面我们来建立针对有限个元素的 Tuple。对于一个元素、两个元素、三个元素，我们可以分别如下实现：

template <typename T0>
struct Tuple
{
T0 _0;
};

template <typename T0, typename T1>
struct Tuple
{
T0 _1;
T1 _1;
};

template <typename T0, typename T1, typename T2>
struct Tuple
{
    T0 _1;
    T1 _1;
    T2 _2;
};

但是这三个写在一起，就会出错。为此，我们可以先定义一个含足够多模版参数的 Tuple，然后上面三个分别作为偏特化版本：

template <typename T0 = NullType, typename T1= NullType, typename T2= NullType, typename T3= NullType, typename T4= NullType>
struct Tuple;

template <typename T0>
struct Tuple<T0>
{
T0 _0;
};

template <typename T0, typename T1>
struct Tuple<T0, T1>
{
T0 _1;
T1 _1;
};

template <typename T0, typename T1, typename T2>
struct Tuple<T0, T1, T2>
{
    T0 _1;
    T1 _1;
    T2 _2;
};

如果手写的话，这也可以。如果不手写，我们可以继续用之前《C++ 下 Function 对象的实现（下）》中的宏循环方案。此方案的一个正式版本见 xlMacros.h。

定义带默认值 NullType 的模版参数声明序列如下：

#define XL_TUPLE_TYPENAME_DECLARE_NT_PATTERN(n) typename T##n = NullType
#define XL_TUPLE_TYPENAME_DECLARE_NT(n) XL_REPZ(XL_TUPLE_TYPENAME_DECLARE_NT_PATTERN, n, XL_COMMA)

它将被展开为： typename T0 = NullType, typename T1 = NullType, typename T2 = NullType, …, typename Tn = NullType

定义不带默认值的模版参数声明序列如下：

#define XL_TUPLE_TYPENAME_DECLARE_PATTERN(n) typename T##n
#define XL_TUPLE_TYPENAME_DECLARE(n) XL_REPZ(XL_TUPLE_TYPENAME_DECLARE_PATTERN, n, XL_COMMA)

它将被展开为：typename T0, typename T1, typename T2, …, typename Tn

定义模版参数使用序列如下：

#define XL_TUPLE_TYPENAME_LIST_PATTERN(n) T##n
#define XL_TUPLE_TYPENAME_LIST(n) XL_REPZ(XL_TUPLE_TYPENAME_LIST_PATTERN, n, XL_COMMA)

它将被展开为 T0, T1, T2, …, Tn

定义成员变量声明序列如下：

#define XL_TUPLE_MEMBER_DECLARE_PATTERN(n) T##n _##n;
#define XL_TUPLE_MEMBER_DECLARE(n) XL_REPZ(XL_TUPLE_MEMBER_DECLARE_PATTERN, n, XL_NIL)

它将被展开为：T0 _0; T1 _1; T2 _2; … Tn _n;

现在我们开始组装：

#ifndef XL_TUPLE_DEFINE_MAX
#define XL_TUPLE_DEFINE_MAX 20
#endif

template <XL_TUPLE_TYPENAME_DECLARE_NT(XL_INC(XL_TUPLE_DEFINE_MAX))>
struct Tuple;

template <XL_TUPLE_TYPENAME_DECLARE(n)>
struct Tuple<XL_TUPLE_TYPENAME_LIST(n)>
{
XL_TUPLE_MEMBER_DECLARE(n)
};

其中后一个还带有宏参数 n。我们将这整一个定义成宏，然后进行宏循环：

#define XL_TUPLE_IMPLEMENT_PATTERN(n)   \
                                        \
template <XL_TUPLE_TYPENAME_DECLARE(n)> \
struct Tuple<XL_TUPLE_TYPENAME_LIST(n)> \
{                                       \
    XL_TUPLE_MEMBER_DECLARE(n)          \
};                                      \

#define XL_TUPLE_IMPLEMENT(n) XL_REPY(XL_TUPLE_IMPLEMENT_PATTERN, n, XL_NIL)

之后再使用这个宏：

XL_TUPLE_IMPLEMENT(XL_TUPLE_DEFINE_MAX)

到此为止，上文一开始提出的 Tuple 已经实现，并支持到最大约 20 个元素左右。

然后我们可以考虑增加各种方便使用的功能。

默认构造函数。
带有 n 个参数的构造函数。相关宏定义：
#define XL_TUPLE_INITIALIZE_LIST_PATTERN(n) _##n(_##n)
#define XL_TUPLE_INITIALIZE_LIST(n) XL_REPZ(XL_TUPLE_INITIALIZE_LIST_PATTERN, n, XL_COMMA)
拷贝构造函数。相关宏定义：
#define XL_TUPLE_INITIALIZE_LIST_COPY_PATTERN(n) _##n(that._##n)
#define XL_TUPLE_INITIALIZE_LIST_COPY(n) XL_REPZ(XL_TUPLE_INITIALIZE_LIST_COPY_PATTERN, n, XL_COMMA)
赋值函数：
#define XL_TUPLE_ASSIGN_PATTERN(n) this->_##n = that._##n;
#define XL_TUPLE_ASSIGN(n) XL_REPZ(XL_TUPLE_ASSIGN_PATTERN, n, XL_NIL)
各种比较函数。请注意对各元素的相应比较运算符的依赖。这里定义成，Tuple 的 < 只依赖于各元素的 <，Tuple 的 != 也只依赖于各元素的 !=，如此类推。

#define XL_TUPLE_EQUAL_PATTERN(n) this->_##n == that._##n
#define XL_TUPLE_EQUAL(n) XL_REPZ(XL_TUPLE_EQUAL_PATTERN, n, &&)

#define XL_TUPLE_NOT_EQUAL_PATTERN(n) this->_##n != that._##n
#define XL_TUPLE_NOT_EQUAL(n) XL_REPZ(XL_TUPLE_NOT_EQUAL_PATTERN, n, ||)

#define XL_TUPLE_LITTER_PATTERN(n)                  if (this->_##n < that._##n)         \
                                                    {                                   \
                                                        return true;                    \
                                                    }                                   \
                                                    else if (that._##n < this->_##n)    \
                                                    {                                   \
                                                        return false;                   \
                                                    }
#define XL_TUPLE_LITTER(n)                          XL_REPZ(XL_TUPLE_LITTER_PATTERN, n, XL_NIL)

#define XL_TUPLE_GREATER_PATTERN(n)                 if (this->_##n > that._##n)         \
                                                    {                                   \
                                                        return true;                    \
                                                    }                                   \
                                                    else if (that._##n > this->_##n)    \
                                                    {                                   \
                                                        return false;                   \
                                                    }
#define XL_TUPLE_GREATER(n)                         XL_REPZ(XL_TUPLE_GREATER_PATTERN, n, XL_NIL)

同时 Tuple 中也增加相应的函数，即可。

最终代码见 xlTuple.h，这里不贴了。

请多多指正。

如何实现一个支持不同类型的 max/min 函数？

溪流 — Tue, 29 Mar 2011 21:27:00 +0000

有个需求，能否做到实现一个类似这样的函数：

template <typename T1, typename T2>
XXX Min(T1 t1, T2 t2)
{
return (t1 < t2 ? t1 : t2);
}

其中 XXX 是我们要推导出的类型。

以下是一个失败的尝试。

我记得 Loki 里有关于如何判断某个类型能否隐式转换为另一个类型的东西，大意如下：

template <typename T, typename U>
class Conversion
{
private:
    typedef char Small;
    class Big { char XXX[2]; };
    static Small Test(U);
    static Big Test(...);
    static T MakeT();
public:
    enum
    {
        Exists = (sizeof(Test(MakeT())) == sizeof(Small)),
    };
};

如此，Conversion<T, U>::Exists 就能判断 T 到 U 的转换是否存在了。

然后再搞个选择：

template <bool Condition, typename TypeIfTrue, typename TypeIfFalse>
struct Select
{
typedef TypeIfFalse Type;
};

template <typename TypeIfTrue, typename TypeIfFalse>
struct Select<true, TypeIfTrue, TypeIfFalse>
{
typedef TypeIfTrue Type;
};

最后，再来个：

struct NullType;

template <typename T, typename U>
struct CommonType
{
    typedef typename Select<Conversion<T, U>::exists,
                                        U,
                                        typename Select<Conversion<U, T>::exists,
                                                                T,
                                                                NullType>::Type
                                       >::Type Type;
};

那么 CommonType<T1, T2> 就是 T1 和 T2 之间哪个是他们的共有类型了。

测试：

int main()
{
CommonType<int, double>::Type m = 0;

return 0;
}

调试，确认 m 是 double 的。但是反过来写 CommonType<double, int>::Type m = 0;，m 却是 int 的。

这说明这套机制一开始就有问题，Test(U) 和 Test(…) 两个重载函数中，Test(…) 不会在需要 double 转 int 时胜出。这是第一个问题。

第二个问题，当写下如下代码的时候：

template <typename T1, typename T2>
CommonType<T1, T2>::Type Min(T1 t1, T2 t2)
{
return (t1 < t2 ? t1 : t2);
}

编译无法通过。原因是返回类型中的 CommonType 中的模板参数 T、U 无法接受此时还不能确定的 T1、T2。

(更正：不是这个原因，返回类型前加 typename 即可。现在问题还是第一个问题。)

请教各位，有没有什么方法做到？欢迎指教~

C++ 0x 中就能很方便做到了：

template <typename T1, typename T2>
auto Min(T1 t1, T2 t2) -> decltype(t1 + t2)
{
return (t1 < t2 ? t1 : t2);
}

int main()
{
    int a = 2;
    double b = 1.0;
    auto m = Min(a, b);

return 0;
}

溪流软件工作室

山寨一个 Boost.Bind

C++ 的几种 cast 运算符到底是什么？与 C 风格的类型转换 (T)value 有什么区别和联系？

翻译一节 C++03 标准文档（3.10 左值和右值），请批评指正~

溪流 WarKey 3.0 正式版已发布

发个 溪流 WarKey 3.0 beta2

还是搞个独立博客玩吧

如果要拟定一份代码规范，哪些内容应该列入？

如何写 执行耗时任务的、可随时立即退出的函数 呢？

一个简单的 Tuple 实现

如何实现一个支持不同类型的 max/min 函数？

发个溪流 WarKey 3.0 beta2

如何写执行耗时任务的、可随时立即退出的函数呢？