微信公众号：编程笔记本

点击上方蓝字关注我，我们一起学编程
欢迎小伙伴们分享、转载、私信、赞赏

今天我们来聊一聊 C++11 新特性。

目录

1、关键字及新语法

1.1、auto 关键字及用法

1. auto 关键字的作用是：编译器根据上下文情况，确定 auto 变量的真正类型。

auto a = 10;             // int
auto b = 10.0;           // double
auto c = "HelloWorld"    // string

2. auto 在 C++14 中可以作为函数的返回值, auto 作为函数返回值时，只能用于定义函数，不能用于声明函数。

用作声明：

#include <iostream>using namespace std;auto testFunc(int a, int b);int main()
{cout << testFunc(1, 2) << endl;return 0;
}auto testFunc(int a, int b)
{return a + b;
}/*
编译报错：
jincheng@haofan:~$ g++ -o test test.cpp
test.cpp: In function ‘int main()’:
test.cpp:9:26: error: use of ‘auto testFunc(int, int)’ before deduction of ‘auto’cout << testFunc(1, 2) << endl;^
jincheng@haofan:~$
*/

用作定义：

#include <iostream>using namespace std;auto testFunc(int a, int b)
{return a + b;
}int main()
{cout << testFunc(1, 2) << endl;return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
3
jincheng@haofan:~$
*/

1.2、nullptr 关键字及用法

NULL 是一个宏定义，与 0 等价，而 nullptr 的类型为 nullptr_t ，能够隐式的转换为任何指针。

#include <iostream>using namespace std;void TestWork(int index)
{cout << "TestWork 1" << endl;
}void TestWork(int *index)
{cout << "TestWork 2" << endl;
}int main()
{TestWork(nullptr);return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
TestWork 2
jincheng@haofan:~$
*/

1.3 范围 for 配合 auto

#include <iostream>
#include <vector>using namespace std;int main()
{vector<int> digits{1, 2, 3, 4, 5};for (auto digit : digits) {cout << digit << endl;}return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
1
2
3
4
5
jincheng@haofan:~$
*/

2、STL容器

2.1、std::array

std::array 与原始数组并没有太大区别，只是增加了迭代器等成员函数。

#include <iostream>
#include <array>using namespace std;int main()
{array<int, 5> digits{1, 2, 3, 4, 5};for (array<int, 5>::iterator it = digits.begin(); it != digits.end(); ++it) {cout << *it << endl;}return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
1
2
3
4
5
jincheng@haofan:~$
*/

2.2、std::forward_list

std::forward_list 是新增的线性表，与 list 的区别在于它是单向链表。链表在对数据进行插入和删除比顺序存储的线性表有优势，因此在插入和删除操作频繁的应用场景中，使用 list 和 forward_list 比使用 array、vector 和 deque 效率要高很多。

#include <iostream>
#include <forward_list>using namespace std;int main()
{forward_list<int> digits;for (int i = 0; i < 5; ++i) {digits.push_front(i);}for (forward_list<int>::iterator it = digits.begin(); it != digits.end(); ++it) {cout << *it << endl;}digits.remove(2);for (auto digit : digits) {cout << digit << endl;}return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
4
3
2
1
0
4
3
1
0
jincheng@haofan:~$
*/

2.3、std::unordered_map

std::unordered_map 又称哈希 map 、无序 map ，它与 std::map 用法基本差不多，但 STL 在内部实现上有很大不同。std::map 的底层数据结构为二叉树（红黑树），而 std::unordered_map 内部是哈希表的实现方式，哈希 map 理论上查找效率为 O(1)。但在存储效率上，哈希 map 需要增加哈希表的内存开销。

#include <iostream>
#include <string>
#include <unordered_map>using namespace std;int main()
{unordered_map<string, int> age ={{"jincheng", 26},{"haofan", 25},{"jindaxia", 18}};cout << "jincheng's age is " << age["jincheng"] << endl;return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
jincheng's age is 26
jincheng@haofan:~$
*/

2.4、std::unordered_set

std::unordered_set 是无序集合，底层的数据存储结构也是哈希表。除此之外，与 std::set 不同的是，std::unordered_set 在插入时不会自动排序。

#include <iostream>
#include <string>
#include <set>
#include <unordered_set>using namespace std;int main()
{set<int> MySet;unordered_set<int> MyUnordered_set;MySet.insert(2);MySet.insert(1);MySet.insert(3);MyUnordered_set.insert(2);MyUnordered_set.insert(1);MyUnordered_set.insert(3);cout << "Elements in set" << endl;for (auto elem : MySet) {cout << elem << "\t";}cout << endl;cout << "Elements in unordered_set" << endl;for (auto elem : MyUnordered_set) {cout << elem << "\t";}cout << endl;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp
jincheng@haofan:~$ ./test
Elements in set
1       2       3
Elements in unordered_set
3       2       1
jincheng@haofan:~$
*/

3、多线程

C++11 中，引入了 boost 库中的多线程部分内容，形成 C++ 标准，形成标准后的 boost 多线程编程部分接口基本没有变化，这样方便了以前使用 boost 接口开发的使用者切换使用 C++ 标准接口，容易把 boost 接口升级为 C++ 接口。

3.1、std::thread

std::thread 是 C++11 的线程类，使用方法和 boost 接口一样，非常方便，同时，C++11 的 std::thread 解决了 boost::thread 中参数限制的问题。

#include <iostream>
#include <thread>
#include <unistd.h>
#include <bits/stdc++.h>using namespace std;void threadfun1(int n)
{for (int i = 0; i < n; ++i) {sleep(1);cout << "theadfun1-HELLO WORLD" << endl;}
}void threadfun2(int n)
{for (int i = 0; i < n; ++i) {sleep(1);cout << "theadfun2-HELLO WORLD" << endl;}
}int main()
{// 绑定线程函数thread t1(threadfun1, 3);thread t2(threadfun2, 5);// 阻塞至线程返回t1.join();t2.join();
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp -lpthread
jincheng@haofan:~$ ./test
theadfun2-HELLO WORLD
theadfun1-HELLO WORLD
theadfun2-HELLO WORLD
theadfun1-HELLO WORLD
theadfun2-HELLO WORLD
theadfun1-HELLO WORLD
theadfun2-HELLO WORLD
theadfun2-HELLO WORLD
jincheng@haofan:~$
*/

3.2、std::atomic

原子数据类型。从功能上简单地说，原子数据类型不会发生数据竞争，能直接用在多线程中而不必用户对其进行添加互斥资源锁的类型。从实现上，可以理解为这些原子类型内部自己加了锁。

/* 使用 2 个线程将 cnt 减至 0 */#include <iostream>
#include <thread>
#include <atomic>
#include <unistd.h>using namespace std;atomic_int cnt(10);void threadfun(int no)
{while (cnt > 0) {sleep(1);cout << "thread" << no <<" cnt : " << cnt-- << endl;}
}int main()
{thread t1(threadfun, 1);thread t2(threadfun, 2);t1.join();t2.join();return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp -lpthread
jincheng@haofan:~$ ./test
thread2 cnt : 10
thread1 cnt : 9
thread2 cnt : 8
thread1 cnt : 7
thread2 cnt : 6
thread1 cnt : 5
thread2 cnt : 4
thread1 cnt : 3
thread2 cnt : 2
thread1 cnt : 1
thread2 cnt : 0
jincheng@haofan:~$
*/

3.3、std::condition_variable

C++11 中的 std::condition_variable 就像 Linux 下使用 pthread_cond_wait 和 pthread_cond_signal 一样，可以让线程休眠，直到被唤醒，再重新执行。线程等待在多线程编程中使用非常频繁，经常需要等待一些异步执行条件的返回结果。

#include <iostream>           // cout
#include <thread>             // thread
#include <mutex>              // mutex, unique_lock
#include <condition_variable> // condition_variableusing namespace std;bool ready = false;
mutex mtx;
condition_variable cv;void print(int id) {unique_lock<mutex> lck(mtx);while (!ready) {cv.wait(lck);    // 锁住当前线程}cout << "thread " << id << endl;
}void go() {unique_lock<mutex> lck(mtx);ready = true;cv.notify_all();    // 通知所有
}int main()
{thread threads[10];for (int i = 0; i < 10; ++i) {threads[i] = thread(print, i);}go();for (auto& t : threads) {t.join();}return 0;
}/*
编译运行：
jincheng@haofan:~$ g++ -o test test.cpp -lpthread
jincheng@haofan:~$ ./test
thread 1
thread 3
thread 4
thread 5
thread 0
thread 6
thread 7
thread 8
thread 9
thread 2
jincheng@haofan:~$
*/

4、智能指针内存管理

在内存管理方面，C++11 的 std::auto_ptr 基础上，移植了 boost 库中的智能指针的部分实现，如 std::shared_ptr、std::weak_ptr 等。简单地说，智能指针只是用对象去管理一个资源指针，同时用一个计数器计算当前指针引用对象的个数，当管理指针的对象增加或减少时，计数器也相应 +1 或 -1，当最后一个指针管理对象销毁时，计数器为 0，此时在销毁指针管理对象的同时，也把指针管理对象所管理的指针进行 delete 操作。

关于智能指针的相关内容，往期笔记 使用STL智能指针就一定不会出现内存泄漏了吗? 已经做了详尽的说明，可点击跳转查看。

以上内容就是整理的部分 C++11 新标准的内容，新标准的内容十分繁多，这里只将常用的几块内容拎出来做个小结。