C++11新特性

最新推荐文章于 2024-08-10 12:33:46 发布
最新推荐文章于 2024-08-10 12:33:46 发布
阅读量253 收藏
点赞数
分类专栏： C++ 文章标签： c++
原文链接：https://zhuanlan.zhihu.com/p/102419965?utm_source=qq
版权

1.Initiallizer list

C++11 提供了统一的语法来初始化任意的对象，例如：

struct A {
    int a;
    float b;
};
struct B {

    B(int _a, float _b): a(_a), b(_b) {}
private:
    int a;
    float b;
};

A a {1, 1.1};    // 统一的初始化语法
B b {2, 2.2};

C++11 还把初始化列表的概念绑定到了类型上，并将其称之为 std::initializer_list，允许构造函数或其他函数像参数一样使用初始化列表，这就为类对象的初始化与普通数组和 POD 的初始化方法提供了统一的桥梁，例如：

#include <initializer_list>

class Magic {
public:
    Magic(std::initializer_list<int> list) {}
};

Magic magic = {1,2,3,4,5};
std::vector<int> v = {1, 2, 3, 4};

2. auto type

std::vector<int> vec = { 1,2,3,4 };
	//c++ 03
	for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); it++) {
		std::cout << *it << std::endl;
	}

	//c++ 11
	for (auto it = vec.begin(); it != vec.end(); it++) {
		std::cout << *it << std::endl;
	}

	auto a = 3 + 2;
	auto s = "123";

注意：auto 不能用于函数传参，因此下面的做法是无法通过编译的（考虑重载的问题，我们应该使用模板）：

int add(auto x, auto y);

此外，auto 还不能用于推导数组类型：

#include <iostream>

int main() {
 auto i = 5;

 int arr[10] = {0};
 auto auto_arr = arr;
 auto auto_arr2[10] = arr;

 return 0;
}

decltype

decltype 关键字是为了解决 auto 关键字只能对变量进行类型推导的缺陷而出现的。它的用法和 sizeof 很相似：

decltype(表达式)

在此过程中，编译器分析表达式并得到它的类型，却不实际计算表达式的值。
有时候，我们可能需要计算某个表达式的类型，例如：

auto x = 1;
auto y = 2;
decltype(x+y) z;

拖尾返回类型、auto 与 decltype 配合

你可能会思考，auto 能不能用于推导函数的返回类型。考虑这样一个例子加法函数的例子，在传统 C++ 中我们必须这么写：

template<typename R, typename T, typename U>
R add(T x, U y) {
    return x+y
}

这样的代码其实变得很丑陋，因为程序员在使用这个模板函数的时候，必须明确指出返回类型。但事实上我们并不知道 add() 这个函数会做什么样的操作，获得一个什么样的返回类型。

在 C++11 中这个问题得到解决。虽然你可能马上回反应出来使用 decltype 推导 x+y 的类型，写出这样的代码：

decltype(x+y) add(T x, U y);

但事实上这样的写法并不能通过编译。这是因为在编译器读到 decltype(x+y) 时，x 和 y 尚未被定义。为了解决这个问题，C++11 还引入了一个叫做拖尾返回类型（trailing return type），利用 auto 关键字将返回类型后置：

template<typename T, typename U>
auto add(T x, U y) -> decltype(x+y) {
    return x+y;
}

从 C++14 开始是可以直接让普通函数具备返回值推导，因此下面的写法变得合法：

template<typename T, typename U>
auto add(T x, U y) {
    return x+y;
}

3. foreach 写c++像是在写c#

std::vector<int> vec = { 1,2,3,4 };
	//c++ 03
	for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); it++) {
		std::cout << *it << std::endl;
	}

	//c++ 11
	//read only（只读）
	for (auto i : vec) {
		std::cout << i << std::endl;
	}
    //只读
    for (const auto& i : vec) {
		std::cout << i << std::endl;
	}
	//changes the values in v（修改）
	for (auto& i : vec) {
		i = 3;
	}

4. nullptr 代替了c++ 03的NULL

nullptr 出现的目的是为了替代 NULL。

在某种意义上来说，传统 C++ 会把 NULL、0 视为同一种东西，这取决于编译器如何定义 NULL，有些编译器会将 NULL 定义为 ((void*)0)，有些则会直接将其定义为 0。
C++ 不允许直接将 void * 隐式转换到其他类型，但如果 NULL 被定义为 ((void*)0)，那么当编译char *ch = NULL;时，NULL 只好被定义为 0。

而这依然会产生问题，将导致了 C++ 中重载特性会发生混乱，考虑：

void foo(char *);
void foo(int);

对于这两个函数来说，如果 NULL 又被定义为了 0 那么 foo(NULL); 这个语句将会去调用 foo(int)，从而导致代码违反直观。
为了解决这个问题，C++11 引入了 nullptr 关键字，专门用来区分空指针、0。

nullptr 的类型为 nullptr_t，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。

当需要使用 NULL 时候，养成直接使用 nullptr的习惯。

5. enum class代替了c++03的enum,更安全

详情请点击这里

        //c++ 03
	enum ship {
		bulkship,
		tankership
	};

	//c++ 11
	enum class ship1 {
		bulkship,
		tankership
	};

6. override关键标识 for virtual function (更加安全，直观 )

class base {
public:
	virtual void fun1(int);
	virtual void fun2() const;
	void fun3(int);
};

class son :public base {
	//c++ 03 存在隐患
	/*
	void fun1(float);  //不小心写错了参数,ok 编译通过，create a new func
	void fun2();       //不小心少写了const,ok 编译通过，create a new func
	void fun3();
	*/

	// but in c++ 11 更安全清晰
	void fun1(float) override; //编译Error: no func to override
	void fun2() override;      //编译Error: no func to override
	void fun3() override;      //编译Error: no func to override			
};

7. final关键标识 ，主要是class 及virtual function

//this is means no class can be derived from CPoint2D
class CPoint2D final {
	//No class can override Draw
	virtual void Draw() final;
};

8. 关键字default标识， compiler generated default constructor

强制编译器生成默认构造函数

  • 编译器不再生成默认构造函数

    class CPoint2D {
public:
	CPoint2D(double x_,double y_) {
		x = x_;
		y = y_;
	}
	double x;
	double y;
};

int main(){	
	CPoint2D pt;//编译报错，不存在默认构造函数，因为编译器不再生成	
}

  • 通过default force compiler to generate the default constructor

    class CPoint2D {
public:
	CPoint2D(double x_,double y_) {
		x = x_;
		y = y_;
	}
	CPoint2D() = default;//告诉编译器强制生成
	double x;
	double y;
};

int main(){	
	CPoint2D pt;//ok	
}

9. 关键标识 delete ,放在函数后面，表示函数不能被调用

  • 看以前的情形，构造函数只接受int，但是输入double也是可以的，因为会自动转换
    class dog {
public:
	dog(int age_) {
		age = age_;
	}
	int age;
};

int main(){	
	dog(2);   //ok
	dog(4.5); //also ok,converted form double to int
}
  • c++ 11 解决方案
    class dog {
public:
	dog(int age_) {
		age = age_;
	}
	dog(double) = delete;
	int age;
};

int main(){	
	dog(2);   //ok
	dog(4.5); //not ok,已经删除的函数
}

10. lambda function, 让编程更优雅

  • 像c#一样优雅起来
    int main(){	
	std::cout << [](int x, int y) {return x + y; }(3, 5) << std::endl;
}
  • 我经常使用std::sort对结构体配合Lammda匿名函数使用，比如点的数组按照x升序排列
    class CPoint2D {
public:
	CPoint2D(double x1,double y1) {
		x = x1; y = y1;
	}
	double x;
	double y;
};
int main(){

	std::vector<CPoint2D> Pts{ {1,1},{3,3},{2,2} };
	std::sort(begin(Pts), end(Pts), [](const CPoint2D& pt1, const CPoint2D& pt2) {
		return  pt1.x < pt2.x;
		});
}

11.smart pointer 智能指针

终于从内存的泥潭中解放出来了，参考另外一篇文章

12. tuple元祖

  • std::pair<std::string,int>的扩展版，可以当做一个通用的结构体来使用
  • tuple 某些情况下会让代码的易读性变差
  • 什么情况下使用tuple

std::pair<>的扩展版，可多个参数

std::pair<int, std::string> p = std::make_pair(2, "hello");
//std::pair的扩展版
std::tuple<int, std::string, char> t(2,"foo",'a');
auto t1 = std::make_tuple(0, "dog", 'b');
std::cout << std::get<0>(t) << std::endl;
std::cout << std::get<1>(t) << std::endl;
std::cout << std::get<2>(t) << std::endl;

易读性会变差（一个使用结构体，一个使用tuple）

结构体比较清晰 p1.name p1.age

tuple易读性差，通过 std::get<0>(t2) std::get<1>(t2)取值

你会想what stored in position 0&what stored in position 1?

struct person {
	std::string name;
	int age;
};
person p1;
std::tuple<std::string, int> t2;

//把上面的代码遮挡起来 tuple会导致代码的易读性降低
std::cout << p1.name << p1.age<<std::endl;
std::cout << std::get<0>(t2) << std::get<1>(t2) << std::endl;
//what stored in position 0?  what stored in position 1?

when to use tuple

(1) As a one-time only structure to transfer g group of data 比如作为函数的返回值使用，这样就不用声明结构体了

std::tuple<std::string,int> GetNameAge(){
	return std::make_tuple("lcl", 20);
}

（2）comparison of tuples

//hours, minutes, seconds

//comparison of tuples
std::tuple<int, int, int> time1, time2;  
if (time1 > time2) {
	//...
}

(3)Muti index map

std::map<std::tuple<int, char, double>, float> m;

插入几张图片 传统c++ 和 Modern c++
在这里插入图片描述在这里插入图片描述在这里插入图片描述

One-Direction
关注
专栏目录
C++11新特性之“=delete“
为他种太阳的博客
07-02 1100
#C++11新特性之"=delete" 删除函数声明是 C++11 标准中引入的一种新形式的函数声明。要将函数声明为已删除的函数，您可以附加**=delete**；该函数声明末尾的说明符。编译器禁用已删除函数的使用。 如果您想阻止其使用，您可以将隐式定义的函数声明为已删除的函数。例如，您可以将类的隐式定义的复制赋值运算符和复制构造函数声明为已删除函数，以防止该类的对象复制。 class A{ public: A(int x) : m(x) {} A& operator = (const
深入理解C++11新特性解析与应用.pdf
03-12
深入理解C++11：C++11新特性解析与应用》主要内容：[0国0]内[0首0]本全面深入解读C++11新标准的专著，由C++标准委员[0会0]代表和IBM XL编译器中[0国0]开发团队共同撰写。不仅详细阐述了C++11标准的设计原则，而且...
C++11学习 新特性之 “=default” 、“=delete”
CHYabc123456hh的博客
09-29 794
文章目录 1、 =default 和=delete 概述 2、 类与默认函数 3、 使用“=delete”来限制函数生成 4、 “=default”使用范围 1、 =default 和=delete 概述 =default、=delete 是C++11的新特性，分别为：显式缺省(告知编译器生成函数默认的缺省版本)和显式删除(告知编译器不生成函数默认的缺省版本)。C++11中引进这两种新特性的目的是为了增强对“类默认函数的控制”，从而让程序员更加精准地去控制默认版本的函数。 其具体的功能和使用方法下
NULL 和 nullptr
最新发布
C18304057755的博客
08-10 311
在C++编程中，NULL和nullptr是两个用于表示空指针的关键字。C++11引入nullptr以解决NULL在函数重载时的二义性问题。NULL在C++中实际上是0，可能导致类型转换错误，而nullptr作为专用的空指针类型，确保了类型安全。因此，推荐使用nullptr来替代NULL以避免潜在的类型转换问题。
C++ NULL与nullptr
个人技术博客
05-17 2347
一，C/C++中的NULL定义 1，C中NULL的定义 #define NULL ((void *)0) C语言中的NULL实质上是一个(void *)指针。 2，C++中NULL的定义 /* Define NULL pointer value */ #ifndef NULL #ifdef __cplusplus #define NULL
C++ std::pair
程序员Link
03-04 739
一 简介 定义于头文件<utility> template <class T1, class T2> struct pair; 二 pair构造函数 // 大致3类 pair( const T1& x, const T2& y ); template< class U1, class U2 > pair( U1&&...
深入理解C++11：C++11新特性解析与应用.rar_C++11新特性_C++11特性说明_深入应用 C++11_深入理解 c
07-14
能较好的说明C++11的特性，起到较好说明功能
C++ 11新特性之大括号初始化详解
01-01
本文主要给大家介绍了关于C++11新特性之大括号初始化的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍： C++11之前，C++主要有以下几种初始化方式： //小括号初始化 string str(hello); ...
C++11 新特性
11-03
以下是对C++11新特性的详细解析： 1. **自动类型推断（Auto）**：C++11引入了`auto`关键字，允许编译器根据初始化表达式自动推断变量的类型，减少了冗余代码，提高了编程效率。 2. **右值引用（Rvalue References...
C++11新特性.pdf
09-14
C++11新特性 C++11是一个重要的升级版本，它引入了许多新特性，极大地提高了C++语言的表达能力和效率。下面将对C++11的一些新特性进行详细介绍。 一、nullptr nullptr是一个C++关键字，它是空指针常量，用来替代...
c++特性之auto
qq_62309585的博客
09-06 950
c++新特性 auto
c++中nullptr与NULL的区别你真的懂吗？
m0_75032658的博客
04-09 266
提供了更好的类型安全性和可读性，因此在编写新的C++代码时，推荐使用。都用于表示空指针，但它们之间存在一些重要的区别。在C++中仍然有效，但。
C++：NULL与nullptr
weixin_53442127的博客
08-05 212
特性NULLnullptr定义通常定义为整数常量0关键字，类型为类型安全可能导致类型不匹配类型安全，不会与其他类型混淆重载解析可能选择错误的重载确保选择指针类型的重载推荐使用不推荐推荐通过使用nullptr，可以编写更安全、更清晰的C++代码，避免由于类型不匹配和重载解析错误引起的问题。
C++中tuple类型
qq_27898413的博客
07-25 9414
tuple是C++11新标准里的类型。它是一个类似pair类型的模板。pair类型是每个成员变量各自可以是任意类型，但是只能有俩个成员，而tuple与pair不同的是它可以有任意数量的成员。但是每个确定的tuple类型的成员数目是固定的。 tuple容器(元组), 是表示元组容器, 是不包含任何结构的,快速而低质(粗制滥造, quick and dirty)的, 可以用于函数返回多个返回值; tuple容器, 可以使用直接初始化, 和"make_tuple()"初始化, 访问元素使用"get<&g
C++11中新特性之：initializer_list详解
weixin_51725434的博客
11-20 8888
C++11提供的新类型，定义在<initializer_list>头文件中。 template< class T > class initializer_list; 先说它的用处吧，然后再详细介绍一下。 首先有了initializer_list之后，对于STL的容器的初始化就方便多了,比如以前初始化一个vector需要这样： int a[] = {0, 1, 2, 3}; std::vector<int> vec(a, a+sizeof(a)); 或者 std::
c++initializer_list详解
qq_36546177的博客
09-23 6187
initializer_list是C++11提供的新类型，定义在头文件中。 用于表示某种特定类型的值的数组，和vector一样，initializer_list也是一种模板类型。 template< class T > class initializer_list; 1 2 要介绍initializer_list的使用，有必要先谈一谈列表初始化。 C++11扩大了初始化列表的适用范围，使其可用于所有内置类型和用户定义的类型。无论是初始化对象还是某些时候为对象赋新值，都可以使用这样一组由
第一章：关于 Initializer_list的理解及用法
ZDY931025的博客
11-10 2406
第一章：关于 Initializer_list的解释及用法 1、Uniform Initializer 一致化的初始化方法 在没有接触C++11之前，对于一个Value或者一个Object的初始化有很多种方法，我们也许会用到小括号，大括号，等号来进行初始化的工作，例如： int a = 0;//新手可能会认为int a;这种写法会给a初始化为0，这是个错误的理解 int array[5] = ...
C++11新特性详解
"C++11新特性" C++11是C++编程语言的一个重大更新，引入了许多新的语言特性和库功能，极大地提高了代码的可读性、效率和安全性。以下是一些C++11的主要新特性： 1. **`__cplusplus` 宏**：在C++11中，`__cplusplus...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值