c++0x keynote中包含一个重要的typeof表达式，用以“自动获取一个类型”，当然是编译期。
一、基本用法。
1、typeof表达式。
以下是它列出的用法：
a、取表达式的值的类型：
template<class A, class B>
function operator*(A a, B b) -> typeof(a*b); // return type last
// big change: function keyword
// : and return are obvious alternatives for ->
template<class A, class B>
typeof(a*b) operator* (A a, B b) ; // “lookahead parsing”
typeof(a*b)并不真的计算a*b的值，而是获得计算的结果类型。
b、取表达式的类型：
template<class A, class B>
typeof(A*B) operator*(A a, B b); // use typenames
// not general
template<class A, class B>
typeof((*(A*)0)*(*(B*)0)) operator*(A a, B b); // hack
目前好像只有gcc编译器支持这个关键字。
2、auto关键字。
auto在老的语法中，是标识存储类型的，表明此变量在本代码块范围内有效，这是默认属性，可以不写，所以感觉有点多余。
在c++0x中，auto有了新用法，它的作用和typeof相似，用法如下：
template<class A, class B> typeof(a*b) operator*(A a, B b)
{
auto x = a*b; // avoid replication of expression/type
// …
return x;
}
auto glob = x*y;
看来它的作用是节省代码的，完全可以用typeof代替。
二、使用。
从上面的基本用法就知道，以往难以处理的不同类型运算问题，它都能轻松处理。
在其它场合，它也能派上用场。比如，我前段时间碰到的一个问题，比如下面一个普通类：
struct A
{
int test ();
};
在另一个类中，想要创建一个兼容A::test类型的委托(自定义的委托类)：
struct B
{
Delegate <int()> test;
};
好象很容易就完成了。不过假如我的类A有10个方法，要在类B中定义10个委托呢？而且还要应对类A中可能发生的变化。
于是我使用了宏来辅助产生类B：
BEGIN_DEFINE(B) // struct B{
METHOD(A,test) // Delegate<...> test;
...
END_DEFINE() // };
METHOD宏就是根据参数中指定的类和方法，产生委托的定义。如何得到A::test的类型？
A::test本身在C++中是个不能确定类型的东西，除非它是static，而&A::test则是一个指针值。还是那个问题，如何得到它的类型？
试图使用traits类模板来分离类型？注意模板类在使用时必须先给出模板参数，只有模板函数可以自行推导出模板参数的类型，而函数不可能出现在类的声明中。
好了，废话不多说了，其实使用typeof是比较简单的实现方法：
template <class T>
class TypeTraits
{
TypeTraits (); // not implemented
};
//多个偏特化版本中的一个
template <class T, class Ret>
struct TypeTraits < Ret(T::*)() >
{
typedef Delegate <Ret()> type;
};
上面的METHOD可以定义为：
#define METHOD(T,x) TypeTraits<typeof(&T::x)>::type x;
这是目前我找到的唯一一个方法，先记录下来。
