一点点开始熟悉C++11的新特性

　　C++11标准由C++标准委员会于2011年8月12日公布，并于2011年9月出版。虽然长期在使用C++，但是对C++11一直处于观望，处于很难用起来（编译器支持等问题），没有很大兴趣去学会的状态。也许风向变到C++11成为主流，才会引起大家的重视和追捧。可是这是常人思维，基本上周围的精英牛人都已经掌握了这些东西，并且已经开始用于工作当中了。 所以这就是我这样的常人和牛人的巨大差别。所以我也要跟上节奏，稍稍学习一下。

auto

C++11中引入auto的作用是为了自动类型推导，将显而易见的类型设定交给编译器来做，这将简化我们的编程工作。而且编译器本来也要计算右边值的类型是否和左边匹配，所以这种自动推导并不会对效率产生不良影响。

auto a;  //错误，完全无法推导类型 
auto i = 5;  
auto d = 6.2;  
auto str = "Hello World";  
auto ch = 'x';  
auto func = less<int>();  //函数指针
vector<int> iv;  
auto ite = iv.begin();  //长长枚举类型不用写了
auto p = new foo() // 对自定义类型进行类型推导 

更高级的用法：

template <typename Product, typename Creator>  
void processProduct(const Creator& creator) {  
    Product* val = creator.makeObject();  
    // do somthing with val  
}         

可以借助auto简化模板参数

template <typename Creator>  
void processProduct(const Creator& creator) {  
    auto val = creator.makeObject();  
    // do somthing with val  
} 

decltype

新的操作符 decltype 可以从一个表达式中“俘获”其结果的类型并“返回”

const vector<int> vi;  
typedef decltype (vi.begin()) CIT;  
CIT another_const_iterator;  //CIT等效vector<int>::iterator

lambda

lambda说简单了就是一个简单的匿名函数，可以灵活混迹于代码当中，不用规规矩矩的声明函数写实现。在C++中它的使用格式是：
capture->return-type {body} 其中capture是lambda表达式可以取得的外部变量，paramters是传入参数，->指向返回值类型，body表达式即函数体。

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;});
for_each(iv.begin(), iv.end(), [=](int &x){x *= (a + b);});
for_each(iv.begin(), iv.end(), [=](int &x)->int{return x * (a + b);});

[=]中间的等号代表lambda表达式可以用所有的外部变量。

nullptr

nullptr 是一个新的 C++ 关键字，它是空指针常量，它是用来替代高风险的 NULL 宏和 0 字面量的。nullptr 是强类型的：

void f(int); //#1  
void f(char *);//#2  
//C++03  
f(0); //调用的是哪个 f?  甚至还有explicit来专门处理这个问题
//C++11  
f(nullptr) //毫无疑问，调用的是 #2  

deleted 和 defaulted 函数

struct A  
{  
 A()=default; //C++11  
 virtual ~A()=default; //C++11  
};  

=default; 指示编译器生成该函数的默认实现。这有两个好处：一是让程序员轻松了，少敲键盘，二是有更好的性能。
与 defaulted 函数相对的就是 deleted 函数，它代表函数删除掉了,如果使用就报错。如下例，用于阻止拷贝：

struct NoCopy  
{  
    NoCopy & operator =( const NoCopy & ) = delete;  
    NoCopy ( const NoCopy & ) = delete;  
};  
NoCopy a;  
NoCopy b(a); //编译错误，拷贝构造函数是 deleted 函数  

优雅的初始化方法

在引入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"}; 

委托构造（代理构造）函数

C++11 中构造函数可以调用同一个类的另一个构造函数：

class M //C++11 delegating constructors  
{  
 int x, y;  
 char *p;  
public:  
 M(int v) : x(v), y(0),  p(new char [MAX])  {} //#1 target  
 M(): M(0) {cout<<"delegating ctor"<<end;} //#2 delegating  
}

记得曾今用过类似的方式，不过直到今天突然迷糊了，不知道当时是用失败了，还是编译器套用了C++11特性才编译通过的。至少说明这是比较有用的新特性。

右值引用

在 C++03 中的引用类型是只绑定左值的，C++11 引用一个新的引用类型叫右值引用类型，它是绑定到右值的，如临时对象或字面量。增加右值引用的主要原因是为了实现 move 语义。与传统的拷贝不同，move 的意思是目标对象“窃取”原对象的资源，并将源置于“空”状态。当拷贝一个对象时，其实代价昂贵且无必要，move 操作就可以替代它。如在 string 交换的时候，使用 move 意义就有巨大的性能提升，如原方案是这样的：

void naiveswap(string &a, string & b)  
{  
 string temp = a;  
 a=b;  
 b=temp;  
}  

这种方案很傻很天真，很慢，因为需要申请内存，然后拷贝字符，而 move 就只需要交换两个数据成员，无须申请、释放内存和拷贝字符数组：

void moveswapstr(string& empty, string & filled)  
{  
//pseudo code, but you get the idea  
 size_t sz=empty.size();  
 const char *p= empty.data();  
//move filled's resources to empty  
 empty.setsize(filled.size());  
 empty.setdata(filled.data());  
//filled becomes empty  
 filled.setsize(sz);  
 filled.setdata(p);  
}  

要实现支持 move 的类，需要声明 move 构造函数和 move 赋值操作符，如下：

class Movable  
{  
Movable (Movable&&); //move constructor  
Movable&& operator=(Movable&&); //move assignment operator  
};  

C++11 的标准库广泛使用 move 语义，很多算法和容器都已经使用 move 语义优化过了。
这一段没看太明白，不过像QT这样的库，几乎把所有对象都实现成了这种“浅拷贝”方式避免简单交换产生的不必要性能消耗。

---

C++11 的标准库

除 TR1 包含的新容器（unordered_set, unordered_map, unordered_multiset, 和unordered_multimap），还有一些新的库，如正则表达式，tuple，函数对象封装器等。下面介绍一些 C++11 的标准库新特性：

线程库
从程序员的角度来看，C++11 最重要的特性就是并发了。C++11 提供了 thread 类，也提供了 promise 和 future 用以并发环境中的同步，用 async() 函数模板执行并发任务，和 thread_local 存储声明为特定线程独占的数据，这里（http://www.devx.com/SpecialReports/Article/38883）有一个简单的 C++11 线程库教程（英文）。

新的智能指针类

C++98 定义的唯一的智能指针类 auto_ptr 已经被弃用，C++11 引入了新的智能针对类 shared_ptr 和 unique_ptr。它们都是标准库的其它组件兼容，可以安全地把智能指针存入标准容器，也可以安全地用标准算法“倒腾”它们。

新的算法
主要是 all_of()、any_of() 和 none_of()，下面是例子：

#include <algorithm>  
//C++11 code  
//are all of the elements positive?  
all_of(first, first+n, ispositive()); //false  
//is there at least one positive element?  
any_of(first, first+n, ispositive());//true  
// are none of the elements positive?  
none_of(first, first+n, ispositive()); //false  

还有一个新的 copy_n：

#include <algorithm>  
int source[5]={0,12,34,50,80};  
int target[5];  
//从 source 拷贝 5 个元素到 target  
copy_n(source,5,target);  

iota() 算法可以用来创建递增序列，它先把初值赋值给 *first，然后用前置 ++ 操作符增长初值并赋值到给下一个迭代器指向的元素，如下：

#include <numeric>  
int a[5]={0};  
char c[3]={0};  
iota(a, a+5, 10); //changes a to {10,11,12,13,14}  
iota(c, c+3, 'a'); //{'a','b','c'}  

是的，C++11 仍然缺少一些很有用的库如 XML API，socket，GUI、反射——以及自动垃圾收集。然而现有特性已经让 C++ 更安全、高效（是的，效率更高了，可以参见 Google 的 基准测试结果http://www.itproportal.com/2011/06/07/googles-rates-c-most-complex-highest-performing-language/）以及更加易于学习和使用。
如果觉得 C++ 变化太大了，不必惊恐，花点时间来学习就好了。可能在你融会贯通新特性以后，你会同意 Stroustrup 的观点：C++11 是一门新的语言——一个更好的 C++。

---

外部资料：
　　30分钟了解C++11新特性
　　C++11中值得关注的几大变化
　　开始使用C++11的9个理由
　　C++11各编译器支持情况对比
　　百度百科C++11
　　微软官方关于现代C++（C++11）的详细资料