【C++11】30分钟了解C++11新特性

 

什么是C++11

C++11是以前被叫做C++0x，是对眼下C++语言的扩展和修正。C++11不仅包括核心语言的新机能，并且扩展了C++的标准程序库（STL）。并入了大部分的C++ Technical Report 1（TR1）程序库(数学的特殊函数除外)。

C++11包含大量的新特性：包含lambda表达式，类型推导keywordauto、decltype，和模板的大量改进。

本文将对C++11的以上新特性进行简单的解说。以便大家可以高速了解到C++11对C++的易用性方面祈祷的巨大作用。

新的keyword

auto

C++11中引入auto第一种作用是为了自己主动类型推导

auto的自己主动类型推导，用于从初始化表达式中判断出变量的数据类型。通过auto的自己主动类型推导，能够大大简化我们的编程工作

auto实际上实在编译时对变量进行了类型推导，所以不会对程序的执行效率造成不良影响

另外，似乎auto并不会影响编译速度，由于编译时本来也要右側推导然后推断与左側是否匹配。

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 <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
}

 

nullptr

nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，由于NULL实际上代表的是0，

void F(int a){
    cout<<a<<endl;
}

void F(int *p){
    assert(p != NULL);

    cout<< p <<endl;
}

int main(){

    int *p = nullptr;
    int *q = NULL;
    bool equal = ( p == q ); // equal的值为true，说明p和q都是空指针
    int a = nullptr; // 编译失败，nullptr不能转型为int
    F(0); // 在C++98中编译失败。有二义性。在C++11中调用F（int）
    F(nullptr);

    return 0;
}

序列for循环

在C++中for循环能够使用类似java的简化的for循环，能够用于遍历数组。容器，string以及由begin和end函数定义的序列（即有Iterator），演示样例代码例如以下：

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类型的变量

变长參数的模板

我们在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之前。仅仅有数组能使用初始化列表，其它容器想要使用初始化列表，仅仅能用下面方法：

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"};