|
|
51CTO旗下网站
|
|
移动端

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

这篇文章介绍下C++14新特性的所有知识点。让我们一起来看看吧。

作者:佚名来源:C语言与C++编程|2020-09-16 10:50

    

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

「函数返回值类型推导」

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

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

使用C++11编译:

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

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

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

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

注意:

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

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

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

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

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

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

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

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

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

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

lambda参数auto

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

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

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

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

变量模板

C++14支持变量模板:

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

别名模板

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

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

constexpr的限制

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

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

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

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

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

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

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

在C++14中可以这样:

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

[[deprecated]]标记

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

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

当编译时,会出现如下警告:

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

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

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

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

std::make_unique

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

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

std::shared_timed_mutex与std::shared_lock

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

实现方式如下:

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

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

std::integer_sequence

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

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

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

std::exchange

直接看代码吧:

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

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

可以看下exchange的实现:

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

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

std::quoted

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

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

编译&输出:

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

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

【责任编辑:庞桂玉 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

云原生架构实践

云原生架构实践

新技术引领移动互联网进入急速赛道
共3章 | KaliArch

5人订阅学习

数据中心和VPDN网络建设案例

数据中心和VPDN网络建设案例

漫画+案例
共20章 | 捷哥CCIE

171人订阅学习

搭建数据中心实验Lab

搭建数据中心实验Lab

实验平台Datacenter
共5章 | ITGO(老曾)

108人订阅学习

视频课程+更多

HarmonyOS工作原理解析

HarmonyOS工作原理解析

讲师:朱有鹏821人学习过

华为HCIP(HCNP)精品课程-Wakin出品

华为HCIP(HCNP)精品课程-Wakin出品

讲师:谢斌3297人学习过

明明白白跨入Vue大门-初级篇

明明白白跨入Vue大门-初级篇

讲师:江成军2629人学习过

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微