auto : 类型自动推导 ( type deduction )
考虑下边这一行程序
auto a1 = 1;
由于 auto 的自动类型推导，a1 自动被编译器识别为 int 类型。更一般的使用方式是这样的：
auto a1 = expression;
也就是说，有了auto之后，变量类型可以由编译器自动从初始化的表达式中识别出来：
int f(); auto a1 = f();
对模板也有用：
template<typename T1, typename T2>
double sum( T1& t1, T2& t2 )
{
auto ans = t1 + t2;
return ans;
}
这看起来有些无聊而且降低了程序的可读性，不过在类型相当复杂的时候非常有用 ：
std::map<std::string, std::string> m;
//for ( std::map<std::string, std::string>::iterator i = m.begin(); i != m.end(); ++i )
for ( auto i = m.begin(); i != m.end(); ++i )
...
而且，得益于 c++0x 新型的 for 循环控制，更方便的写法是：
for ( auto i : m )
...
当然，如果想修改 m 元素的内容，就要用引用：
for ( auto& i : m )
...
更进一步
auto 可以与 static，const，volatile，* 和 & 等一起用：
int f(); auto i1 = f(); const auto i2 = f(); const auto& = f();
再如：
int* f(); auto i = f(); auto* i = f(); const auto* i = f();
碰到引用时跟指针稍微有些区别：
int& f(); auto i1 = f(); auto& i2 = f(); const auto& i3 = f();
上边变量 i1 的类型是 int ，不是 int& 。
auto 在涉及到虚拟继承时候类型推导也没有什么问题：
struct b
{
virtual void operator()() const
{
cout << "b()()\n";
}
};
struct d : b
{
virtual void operator()() const
{
cout << "d()()\n";
}
};
auto p1 = new d;
(*p1)();
auto p2 = p1;
(*p2)();
b* p3 = new d;
auto p4 = p3;
(*p4)();
输出都是 d()() 。
auto 直接初始化写法是非常容易上手的：
auto i = 1; const auto i = 1; static auto i = 1; const auto& i = 1;
包括指针初始化：
int * i = new int(1); auto i = new auto(1); auto* i = new auto(1);
上边三句执行动作完全一样。
有多个变量要一起 auto 也行：
auto i = 1, j = 2; auto i = 1, *j = &i;
auto k = 0; auto* i = &k, j = 1;
只要不试图调戏编译器就可以：
auto i = &i;//error auto i = 1, j = 1.0;//error
更多
一个比较无聊的用法可以是这样的：
auto int i;
变量 i 被定义为 int 类型，不需要初始化参量。
碰到数组时候稍微尴尬点：
auto v1 = {1, 2, 3};
auto v1[3] = {1, 2, 3};//error
auto v1[] = {1, 2, 3}; //error
int v[3];
auto v2 = v;
auto v2[3] = v;//error
auto v2[] = v; //error
编译环境:
linux 2.6.35
g++ 4.5
编译选项：
-std=c++0x
完整编译：
g++ –o test test.cc -std=c++0x
(感谢pengxinglove 建议)
