auto,

C++11 auto

auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型.

#include <iostream>
#include <typeinfo>
using namespace std;

int main()
{
        int a = 10;
        auto au_a = a;
        cout<<typeid(au_a).name()<<endl;
        char c;
        auto ch = c;
        cout<<typeid(ch).name()<<endl;
        return 0;
}

运行（加入Ｃ＋＋１１特性）：
g++ -std=c++11 b.cpp

auto的自动类型推断发生在编译期，所以使用auto并不会造成程序运行时效率的降低。而是否会造成编译期的时间消耗，我认为是不会的，在未使用auto时，编译器也需要得知右操作数的类型，再与左操作数的类型进行比较，检查是否可以发生相应的转化，是否需要进行隐式类型转换。

用于代替冗长复杂、变量使用范围专一的变量声明。
想象一下在没有auto的时候，我们操作标准库时经常需要这样：

#include<string>
#include<vector>
int main()
{
    std::vector<std::string> vs;
    for (std::vector<std::string>::iterator i = vs.begin(); i != vs.end(); i++)
    {
        //...
    }
}

这样看代码写代码实在烦得很。有人可能会说为何不直接使用using namespace std，这样代码可以短一点。实际上这不是该建议的方法（C++Primer对此有相关叙述）。使用auto能简化代码：

#include<string>
#include<vector>
int main()
{
    std::vector<std::string> vs;
    for (auto i = vs.begin(); i != vs.end(); i++)
    {
        //..
    }
}

for循环中的i将在编译时自动推导其类型，而不用我们显式去定义那长长的一串。（必须以C++11的特性来编译才不会出错。）

auto 变量必须在定义时初始化，这类似于const关键字
定义在一个auto序列的变量必须始终推导成同一类型。例如：

auto a4 = 10, a5 = 20, a6 = 30;//正确
auto b4 = 10, b5 = 20.0, b6 = 'a';//错误,没有推导为同一类型

如果auto初始化表达式是引用,const, volatile，则去除引用,const,volatile语义。
如果关键字带上引用，const, volatile，则不去除相应语意。

#include <iostream>
#include <typeinfo>
#include <vector>

int main()
{
        int a = 10; 
        int &b = a; 
        auto c = b; //c的类型为int而非int&(去除引用)
        auto &d = b;//加了&,则不去除引用语意,此时ｄ的类型为int&

        b = 20;
        std::cout<<a<<std::endl;
        c = 200;
        std::cout<<a<<std::endl;
        d = 300;
        std::cout<<d<<std::endl;
}

const int a1 = 10;
auto  b1= a1; //b1的类型为int而非const int（去除const）
const auto c1 = a1;//此时c1的类型为const int
b1 = 100;//合法
c1 = 100;//非法

时刻要注意auto并不是一个真正的类型。
auto仅仅是一个占位符，它并不是一个真正的类型，不能使用一些以类型为操作数的操作符，如sizeof或者typeid。

cout << sizeof(auto) << endl;//错误
cout << typeid(auto).name() << endl;//错误

本文参考：http://www.cnblogs.com/QG-whz/p/4951177.html