[转载]C++11中值得关注的几大变化

Lambda表达式

Lambda表达式来源于函数式编程，说折了就是在使用的地方定义函数，有的语言叫“闭包”，如果Lambda函数没有传回值（例如void），其返回类型可被完全忽略。定义在与lambda函数相同作用域的变量参考也可以被使用。这种的变量一般被称作closure（闭包）。我在这里就不再讲这个事了。表达式的简单语法如下，

[capture](parameters)->return_type {body}

原文的作者给出了下面的例子：

int main()
{
  char s[] = "Hello World!";
  int Uppercase = 0; //modified by the lambda
  for_each(s, s+sizeof(s), [&Uppercase] (char c) {
    if (isuper(c))
      Uppercase++;
  });
  cout<< Uppercase << "uppercase letters in: " << s << endl;
}

在传统的STL中for_each()这个玩意最后那个参数需要一个“函数对象”，所谓函数对象，其实是一个class，这个class重载了operator()，于是这个对象可以像函数的式样的使用。实现一个函数对象并不容易，需要使用template，比如下面这个例子就是函数对象的简单例子（实际的实现远比这个复杂）

template <class T>
class less
{
public:
    bool operator() (const T&l, const T&r) const
    {
        return l<r;
    }
};

所以，C++引入Lambda的最主要原因就是1) 可以定义匿名函数， 2）编译器会把其转成函数对象。相信你和我一样，会疑问为什么以前STL中的ptr_fun()这个函数对象不能用？(ptr_fun()就是把一个自然函数转成函数对象的）。原因是，ptr_fun()的局限是其接收的自然函数只能有1或2个参数。
那么，除了方便外，为什么一定要使用Lambda呢？它比传统的函数或是函数对象有什么好处呢？我个人理解的是，这种函数之所以叫“闭包”，就是因为其限制了别人的访问，更私有。也可以颤颤他是一次性的方法。Lambda表达式应该是简洁的，极私有的，为了更易的代码和更方便的编程。

自动类型推导auto
在这一节中，原文主要介绍了两个关键字auto和deltype，示例如下:

auto x = 0; // x has type int because 0 is int
auto c = 'a'; //char 
auto d = 0.5; //double
auto national_debt = 14400000000000LL; // long long

auto最大的好处就是让代码简洁，尤其是那些模板类的声明，比如：STL中的容器的迭代子类型。

vector<int>::const_iterator ci = vi.begin();

可以变成：

auto ci = vi.begin();

模板这个特性让C++的代码变得很难读，不信你可以看看STL的源码，那是一个乱啊。使用auto必需一个初始化值，编译器可以通过这个初始化值推导出类型。因为auto是来简化模板类引入的代码难读的问题，如上面的示例，iteration这种类型就最适合用auto的，但是，我们不应该把其滥用。
比如下面的代码的可读性就降低了。因为，我不知道ProcessData返回什么？int?bool?还是对象？或是别的什么？这让你后面的程序不知道怎么做。

auto obj = ProcessData(someVariables);

但是下面的程序就没有问题，因为pObject的型别在后面的new中有了。

auto pObject = new SomeType<OtherType>::SomeOtherType();

自动化推导decltype
关于decltype是一个操作符，其可以评估括号内表达式的类型，其规则如下：

1. 如果表达式e是一个变量，那么就是这个变量的类型。
2. 如果表达式e是一个函数，那么就是这个函数返回值的类型。
3. 如果不符合1和2，如果e是左值，类型为T，那么decltype(e)是T&；如果是右值，则是T。
   原文给出的示例如下，我们可以看到，这个的确让我们定义变量省了很多事。

const vector<int> vi;
typedef decltype (vi.begin()) CIT;
CIT another_const_iterator;

还有一个适合的用法是用来typedef函数指针，也会省很多事。比如：

decltype(&myfunc) pfunc = 0;
typedef decltype(&A::func1) type;

auto和decltype的差别和关系
Wikipedia上是这么说的(关于decltype的规则见上)

#include <vector>
int main()
{
    const std::vector<int> v(1);
    auto a = v[0];        // a 的类型是 int
    decltype(v[0]) b = 1; // b 的类型是 const int&, 因为函数的返回类型是
                          // std::vector<int>::operator[](size_type) const
    auto c = 0;           // c 的类型是 int
    auto d = c;           // d 的类型是 int
    decltype(c) e;        // e 的类型是 int,因为c的类型是int
    decltype((c)) f = c;  // f 的类型是 int&, 因为(c)是左值
    decltype(0) g;        // g 的类型是 int, 因为0是右值

}

如果auto和decltype在一起使用会是什么样子？看下面的示例，下面这个示例也是引入decltype的一个原因—让C++有能力写一个“forwarding function模板”,

template<typename LHS, typename RHS>
  auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs)
{return lhs + rhs;}

这个函数模板看起来相当费解，其用到了auto和decltype来扩展已有的模板技术的不足。怎么个不足呢？在上例中，我不知道AddingFunc会接收什么样类型的对象，这两个对象的+操作符返回的类型也不知道，老的模板函数无法定义AddingFunc返回值和这两个对象相加后的返回值匹配，所以，你可以使用上述的这种定义。
统一的初始化语法