C++14新特性的所有知识点全在这儿啦！

前面程序喵介绍过C++11的新特性，这篇文章介绍下C++14的新特性。

创新互联建站主营罗城网站建设的网络公司,主营网站建设方案,App定制开发,罗城h5重庆小程序开发搭建,罗城网站营销推广欢迎罗城等地区企业咨询

「函数返回值类型推导」

C++14对函数返回类型推导规则做了优化，先看一段代码： 

 
 
 
    
  
  
  
  1. #include   
    2. 
  
  
  
  2. using namespace std;  
    3. 
  
  
  
  3. auto func(int i) {  
    4. 
  
  
  
  4.    return i;  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. int main() {  
    7. 
  
  
  
  7.    cout << func(4) << endl;  
    8. 
  
  
  
  8.    return 0;  
    9. 
  
  
  
  9. } 
    10.

使用C++11编译： 

 
 
 
    
  
  
  
  1. ~/test$ g++ test.cc -std=c++11  
    2. 
  
  
  
  2. test.cc:5:16: error: ‘func’ function uses ‘auto’ type specifier without trailing return type  
    3. 
  
  
  
  3. auto func(int i) {  
    4. 
  
  
  
  4.                ^  
    5. 
  
  
  
  5. test.cc:5:16: note: deduced return type only available with -std=c++14 or -std=gnu++14 
    6.

上面的代码使用C++11是不能通过编译的，通过编译器输出的信息也可以看见这个特性需要到C++14才被支持。

返回值类型推导也可以用在模板中： 

 
 
 
    
  
  
  
  1. #include   
    2. 
  
  
  
  2. using namespace std;  
    3. 
  
  
  
  3. template auto func(T t) { return t; }  
    4. 
  
  
  
  4. int main() { 
    5. 
  
  
  
  5.    cout << func(4) << endl;  
    6. 
  
  
  
  6.    cout << func(3.4) << endl;  
    7. 
  
  
  
  7.    return 0;  
    8. 
  
  
  
  8. } 
    9.

注意：

函数内如果有多个return语句，它们必须返回相同的类型，否则编译失败 

 
 
 
    
  
  
  
  1. auto func(bool flag) {  
    2. 
  
  
  
  2.    if (flag) return 1;  
    3. 
  
  
  
  3.    else return 2.3; // error  
    4. 
  
  
  
  4. }  
    5. 
  
  
  
  5. // inconsistent deduction for auto return type: ‘int’ and then ‘double’ 
    6.

如果return语句返回初始化列表，返回值类型推导也会失败 

 
 
 
    
  
  
  
  1. auto func() {  
    2. 
  
  
  
  2.    return {1, 2, 3}; // error returning initializer list  
    3. 
  
  
  
  3. } 
    4.

如果函数是虚函数，不能使用返回值类型推导 

 
 
 
    
  
  
  
  1. struct A {  
    2. 
  
  
  
  2. // error: virtual function cannot have deduced return type  
    3. 
  
  
  
  3. virtual auto func() { return 1; }  
    4. 
  
  
  
  4. } 
    5.

返回类型推导可以用在前向声明中，但是在使用它们之前，翻译单元中必须能够得到函数定义 

 
 
 
    
  
  
  
  1. auto f();               // declared, not yet defined  
    2. 
  
  
  
  2. auto f() { return 42; } // defined, return type is int  
    3. 
  
  
  
  3. int main() {  
    4. 
  
  
  
  4. cout << f() << endl;  
    5. 
  
  
  
  5. } 
    6.

返回类型推导可以用在递归函数中，但是递归调用必须以至少一个返回语句作为先导，以便编译器推导出返回类型。 

 
 
 
    
  
  
  
  1. auto sum(int i) {  
    2. 
  
  
  
  2.    if (i == 1)  
    3. 
  
  
  
  3.        return i;              // return int  
    4. 
  
  
  
  4.    else  
    5. 
  
  
  
  5.        return sum(i - 1) + i; // ok  
    6. 
  
  
  
  6. } 
    7.

lambda参数auto

在C++11中，lambda表达式参数需要使用具体的类型声明： 

 
 
 
    
  
  
  
  1. auto f = [] (int a) { return a; } 
    2.

在C++14中，对此进行优化，lambda表达式参数可以直接是auto： 

 
 
 
    
  
  
  
  1. auto f = [] (auto a) { return a; };  
    2. 
  
  
  
  2. cout << f(1) << endl;  
    3. 
  
  
  
  3. cout << f(2.3f) << endl; 
    4.

变量模板

C++14支持变量模板： 

 
 
 
    
  
  
  
  1. template  
    2. 
  
  
  
  2. constexpr T pi = T(3.1415926535897932385L);  
    3. 
  
  
  
  3. int main() {  
    4. 
  
  
  
  4.    cout << pi << endl; // 3  
    5. 
  
  
  
  5.    cout << pi << endl; // 3.14159  
    6. 
  
  
  
  6.    return 0;  
    7. 
  
  
  
  7. } 
    8.

别名模板

C++14也支持别名模板： 

 
 
 
    
  
  
  
  1. template  
    2. 
  
  
  
  2. struct A {  
    3. 
  
  
  
  3.    T t;  
    4. 
  
  
  
  4.    U u;  
    5. 
  
  
  
  5. };  
    6. 
  
  
  
  6. template  
    7. 
  
  
  
  7. using B = A;  
    8. 
  
  
  
  8. int main() {  
    9. 
  
  
  
  9.    B b;  
    10. 
  
  
  
  10.    b.t = 10;  
    11. 
  
  
  
  11.    b.u = 20;  
    12. 
  
  
  
  12.    cout << b.t << endl;  
    13. 
  
  
  
  13.    cout << b.u << endl;  
    14. 
  
  
  
  14.    return 0;  
    15. 
  
  
  
  15. } 
    16.

constexpr的限制

C++14相较于C++11对constexpr减少了一些限制：

C++11中constexpr函数可以使用递归，在C++14中可以使用局部变量和循环 

 
 
 
    
  
  
  
  1. constexpr int factorial(int n) { // C++14 和 C++11均可  
    2. 
  
  
  
  2.    return n <= 1 ? 1 : (n * factorial(n - 1));  
    3. 
  
  
  
  3. } 
    4.

在C++14中可以这样做： 

 
 
 
    
  
  
  
  1. constexpr int factorial(int n) { // C++11中不可，C++14中可以  
    2. 
  
  
  
  2.    int ret = 0;  
    3. 
  
  
  
  3.    for (int i = 0; i < n; ++i) {  
    4. 
  
  
  
  4.        ret += i;  
    5. 
  
  
  
  5.   }  
    6. 
  
  
  
  6.    return ret;  
    7. 
  
  
  
  7. } 
    8.

C++11中constexpr函数必须必须把所有东西都放在一个单独的return语句中，而constexpr则无此限制 

 
 
 
    
  
  
  
  1. constexpr int func(bool flag) { // C++14 和 C++11均可  
    2. 
  
  
  
  2.    return 0; 
    3. 
  
  
  
  3.  } 
    4.

在C++14中可以这样： 

 
 
 
    
  
  
  
  1. constexpr int func(bool flag) { // C++11中不可，C++14中可以  
    2. 
  
  
  
  2.    if (flag) return 1;  
    3. 
  
  
  
  3.    else return 0;  
    4. 
  
  
  
  4. } 
    5.

标记

C++14中增加了deprecated标记，修饰类、变、函数等，当程序中使用到了被其修饰的代码时，编译时被产生警告，用户提示开发者该标记修饰的内容将来可能会被丢弃，尽量不要使用。 

 
 
 
    
  
  
  
  1. struct[[deprecated]]A { };  
    2. 
  
  
  
  2. int main() { 
    3. 
  
  
  
  3.      A a;  
    4. 
  
  
  
  4.     return 0;  
    5. 
  
  
  
  5. } 
    6.

当编译时，会出现如下警告： 

 
 
 
    
  
  
  
  1. ~/test$ g++ test.cc -std=c++14  
    2. 
  
  
  
  2. test.cc: In function ‘int main()’:  
    3. 
  
  
  
  3. test.cc:11:7: warning: ‘A’ is deprecated [-Wdeprecated-declarations]  
    4. 
  
  
  
  4.      A a;  
    5. 
  
  
  
  5.        ^  
    6. 
  
  
  
  6. test.cc:6:23: note: declared here  
    7. 
  
  
  
  7.  struct[[deprecated]]A { 
    8.

二进制字面量与整形字面量分隔符

C++14引入了二进制字面量，也引入了分隔符，防止看起来眼花哈~ 

 
 
 
    
  
  
  
  1. int a = 0b0001'0011'1010;  
    2. 
  
  
  
  2. double b = 3.14'1234'1234'1234; 
    3.

std::make_unique

我们都知道C++11中有std::make_shared，却没有std::make_unique，在C++14已经改善。 

 
 
 
    
  
  
  
  1. struct A {};  
    2. 
  
  
  
  2. std::unique_ptr ptr = std::make_unique(); 
    3.

std::shared_timed_mutex与std::shared_lock

C++14通过std::shared_timed_mutex和std::shared_lock来实现读写锁，保证多个线程可以同时读，但是写线程必须独立运行，写操作不可以同时和读操作一起进行。

实现方式如下： 

 
 
 
    
  
  
  
  1. struct ThreadSafe {  
    2. 
  
  
  
  2.     mutable std::shared_timed_mutex mutex_;  
    3. 
  
  
  
  3.     int value_; 
    4. 
  
  
  
  4.     ThreadSafe() {  
    5. 
  
  
  
  5.         value_ = 0;  
    6. 
  
  
  
  6.     }  
    7. 
  
  
  
  7.     int get() const {  
    8. 
  
  
  
  8.         std::shared_lock loc(mutex_);  
    9. 
  
  
  
  9.         return value_;  
    10. 
  
  
  
  10.     }  
    11. 
  
  
  
  11.     void increase() { 
    12. 
  
  
  
  12.          std::unique_lock lock(mutex_);  
    13. 
  
  
  
  13.         value_ += 1;  
    14. 
  
  
  
  14.     }  
    15. 
  
  
  
  15. }; 
    16.

为什么是timed的锁呢，因为可以带超时时间，具体可以自行查询相关资料哈，网上有很多。

std::integer_sequence 

 
 
 
    
  
  
  
  1. template  
    2. 
  
  
  
  2. void print_sequence(std::integer_sequence int_seq)  
    3. 
  
  
  
  3. {  
    4. 
  
  
  
  4.     std::cout << "The sequence of size " << int_seq.size() << ": ";  
    5. 
  
  
  
  5.     ((std::cout << ints << ' '), ...);  
    6. 
  
  
  
  6.     std::cout << '\n';  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. int main() {  
    9. 
  
  
  
  9.     print_sequence(std::integer_sequence{});  
    10. 
  
  
  
  10.     return 0;  
    11. 
  
  
  
  11. }  
    12. 
  
  
  
  12. 输出：7 9 2 5 1 9 1 6 
    13.

std::integer_sequence和std::tuple的配合使用： 

 
 
 
    
  
  
  
  1. template   
    2. 
  
  
  
  2. auto map_filter_tuple(F f, T& t) {  
    3. 
  
  
  
  3.     return std::make_tuple(f(std::get(t))...);  
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5. template   
    6. 
  
  
  
  6. auto map_filter_tuple(std::index_sequence, F f, T& t) {  
    7. 
  
  
  
  7.     return std::make_tuple(f(std::get(t))...);  
    8. 
  
  
  
  8. }  
    9. 
  
  
  
  9. template   
    10. 
  
  
  
  10. auto map_filter_tuple(F&& f, T& t) {  
    11. 
  
  
  
  11.     return map_filter_tuple(S{}, std::forward(f), t);  
    12. 
  
  
  
  12. } 
    13.

std::exchange

直接看代码吧： 

 
 
 
    
  
  
  
  1. int main() {  
    2. 
  
  
  
  2.     std::vector v;  
    3. 
  
  
  
  3.     std::exchange(v, {1,2,3,4});  
    4. 
  
  
  
  4.     cout << v.size() << endl;  
    5. 
  
  
  
  5.     for (int a : v) {  
    6. 
  
  
  
  6.         cout << a << " ";  
    7. 
  
  
  
  7.     }  
    8. 
  
  
  
  8.     return 0;  
    9. 
  
  
  
  9. } 
    10.

看样子貌似和std::swap作用相同，那它俩有什么区别呢？

可以看下exchange的实现： 

 
 
 
    
  
  
  
  1. template  
    2. 
  
  
  
  2. constexpr T exchange(T& obj, U&& new_value) {  
    3. 
  
  
  
  3.     T old_value = std::move(obj);  
    4. 
  
  
  
  4.     obj = std::forward(new_value);  
    5. 
  
  
  
  5.     return old_value;  
    6. 
  
  
  
  6. } 
    7.

可以看见new_value的值给了obj，而没有对new_value赋值，这里相信您已经知道了它和swap的区别了吧！

std::quoted

C++14引入std::quoted用于给字符串添加双引号，直接看代码： 

 
 
 
    
  
  
  
  1. int main() {  
    2. 
  
  
  
  2.     string str = "hello world";  
    3. 
  
  
  
  3.     cout << str << endl; 
    4. 
  
  
  
  4.     cout << std::quoted(str) << endl;  
    5. 
  
  
  
  5.     return 0;  
    6. 
  
  
  
  6. } 
    7.

编译&输出： 

 
 
 
    
  
  
  
  1. ~/test$ g++ test.cc -std=c++14  
    2. 
  
  
  
  2. ~/test$ ./a.out  
    3. 
  
  
  
  3. hello world  
    4. 
  
  
  
  4. "hello world" 
    5.

关于C++14，我们今天先说到这里。 

文章名称：C++14新特性的所有知识点全在这儿啦！
网页链接：http://www.csdahua.cn/qtweb/news1/37851.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

服务器托管知识

分类信息网

网络营销推广　　 　双流能亿建站　　 　软文营销　　 　圣月冷冻库　　 　高端网站建设　　 　企业画册设计制作　　 　成都网站设计　　 　铁科精智测控　　 　关键词优化排名　　 　网站推广公司　　 　四川成都做网站　　 　江油网站建设　　 　网页改版　　 　led发光广告字　　 　四川主机托管　　 　成都光华机房　　 　防护网厂　　 　成都app开发公司　　 　重庆网站建设　　 　德阳东方电机技改