auto
C++11中引入auto第一种作用是为了自动类型推导
auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作
auto实际上实在编译时对变量进行了类型推导，所以不会对程序的运行效率造成不良影响
//C++ 11， 14 新特性
// 1. auto 类型帮助程序员 做类型推导， 是类型安全的。让代码更简洁
vector<string> data;
auto itor = data.begin(); // auto 代替了 vector<string>::iterator
// decltype 点像auto的反函数 得到变量的 类型
decltype(itor) itor2 = data.begin();auto a; // 错误，auto是通过初始化表达式进行类型推导，如果没有初始化表达式，就无法确定a的类型
auto i = 1;
auto d = 1.0;
auto str = "Hello World";
auto ch = 'A';
auto func = less<int>();
vector<int> iv;
auto ite = iv.begin();
auto p = new foo() // 对自定义类型进行类型推导 auto不光有以上的应用，它在模板中也是大显身手，比如下例这个加工产品的例子中，如果不使用auto就必须声明Product这一模板参数：
template <typename Product, typename Creator>
void processProduct(const Creator& creator) {
Product* val = creator.makeObject();
// do somthing with val
}
.
如果使用auto，则可以这样写： 可以减少 template 模板的使用
template <typename Creator>
void processProduct(const Creator& creator) {
auto val = creator.makeObject();
// do somthing with val
}
抛弃了麻烦的模板参数，整个代码变得更加正解了。decltype
decltype实际上有点像auto的反函数，auto可以让你声明一个变量，而decltype则可以从一个变量或表达式中得到类型，有实例如下：
int x = 3;
decltype(x) y = x;
有人会问，decltype的实用之处在哪里呢，我们接着上边的例子继续说下去，如果上文中的加工产品的例子中我们想把产品作为返回值该怎么办呢？我们可以这样写：
template <typename Creator>
auto processProduct(const Creator& creator) -> decltype(creator.makeObject()) {
auto val = creator.makeObject();
// do somthing with val
} 序列for循环
在C++中for循环可以使用类似java的简化的for循环，可以用于遍历数组，容器，string以及由begin和end函数定义的序列（即有Iterator），示例代码如下：
vector<int> data_int = {1,2,3};
// 5. 序列 for 循环 类似与 JAVA 的增强for
for (auto da : data_int)
{
cout << "da is:" <<da<< endl;
}map<string, int> m{{"a", 1}, {"b", 2}, {"c", 3}};
for (auto p : m){
cout<<p.first<<" : "<<p.second<<endl;
} Lambda表达式
lambda表达式类似Javascript中的闭包，它可以用于创建并定义匿名的函数对象，以简化编程工作。Lambda的语法如下：
[函数对象参数]（操作符重载函数参数）->返回值类型{函数体}
vector<int> iv{5, 4, 3, 2, 1};
int a = 2, b = 1;
for_each(iv.begin(), iv.end(), [b](int &x){cout<<(x + b)<<endl;}); // (1)
for_each(iv.begin(), iv.end(), [=](int &x){x *= (a + b);}); // (2)
for_each(iv.begin(), iv.end(), [=](int &x)->int{return x * (a + b);});// (3) - []内的参数指的是Lambda表达式可以取得的全局变量。(1)函数中的b就是指函数可以得到在Lambda表达式外的全局变量，如果在[]中传入=的话，即是可以取得所有的外部变量，如（2）和（3）Lambda表达式
- ()内的参数是每次调用函数时传入的参数。
- ->后加上的是Lambda表达式返回值的类型，如（3）中返回了一个int类型的变量
// 3. lambda 函数 adder是函数 //int (* p)(int, int) = [](int p1, int p2) {return p1 + p2; }; 以前的写法 ，使用 auto 扩展性更强 auto adder = [](auto op1, auto op2) {return op1 + op2; }; cout << "int result:" << std::accumulate(data_int.begin(), data_int.end(), 0, adder) << endl; cout << "string result:" << std::accumulate(data_string.begin(), data_string.end(), string(""), adder) << endl; cout << "sum is:" << adder(1, 3) << endl;
nullptr
nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，因为NULL实际上代表的是0，
变长参数的模板
我们在C++中都用过pair，pair可以使用make_pair构造，构造一个包含两种不同类型的数据的容器。比如，如下代码：
auto p = make_pair(1, "C++ 11");
由于在C++11中引入了变长参数模板，所以发明了新的数据类型：tuple，tuple是一个N元组，可以传入1个， 2个甚至多个不同类型的数据
auto t1 = make_tuple(1, 2.0, "C++ 11");
auto t2 = make_tuple(1, 2.0, "C++ 11", {1, 0, 2});
这样就避免了从前的pair中嵌套pair的丑陋做法，使得代码更加整洁
另一个经常见到的例子是Print函数，在C语言中printf可以传入多个参数，在C++11中，我们可以用变长参数模板实现更简洁的Print
template<typename head, typename... tail>
void Print(Head head, typename... tail) {
cout<< head <<endl;
Print(tail...);
}
Print中可以传入多个不同种类的参数，如下：
Print(1, 1.0, "C++11"); 通过类型寻址多元组
C++11引入的 tuple 类型允许不同类型的值的聚合体用编译期整型常数索引。C++14还允许使用类型代替常数索引，从多元组中获取对象。若多元组含有多于一个这个类型的对象，将会产生一个编译错误：
tuple<string, string, int> t("foo", "bar", 7);
int i = get<int>(t); // i == 7
int j = get<2>(t); // Same as before: j == 7
string s = get<string>(t); //Compiler error due to ambiguity
初始化列表
在引入C++11之前，只有数组能使用初始化列表，其他容器想要使用初始化列表，只能用以下方法：
int arr[3] = {1, 2, 3}
vector<int> v(arr, arr + 3);
在C++11中，我们可以使用以下语法来进行替换：
int arr[3]{1, 2, 3};
vector<int> iv{1, 2, 3};
map<int, string>{{1, "a"}, {2, "b"}};
string str{"Hello World"};
//2. vector 的初始化
vector<int> data_int = {1,2,3};
vector<string> data_string = {"1", "2", "3"};