C++ 2.0 //C++ 11总结

于 2021-03-25 17:11:54 发布
阅读量386 收藏
点赞数
分类专栏： c++11 c++2.0 侯捷 文章标签： c++ c++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxx21/article/details/115168114
版权
c++11 同时被 3 个专栏收录
1 篇文章 0 订阅
订阅专栏
c++2.0
1 篇文章 0 订阅
订阅专栏
侯捷
1 篇文章 0 订阅
订阅专栏

C++ 2.0 //C++ 11

1.variadic template(数量不定的模板)

用… 表示数量不定

#include<cstdlib>
#include<iostream>
#include<string>
using namespace std;
void print() {
	//相当于递归出口
}
template<typename T,typename...Types>
void print(T first ,Types... args) {
	cout << first << endl;
	print(args...);
}
int main() {
	print(1, 2.3, "hello");
	system("pause");
	return 0;
}

1
2.3
hello
请按任意键继续. . .

通过递归继承来实现简单tuple

#include<cstdlib>
#include<iostream>
#include<string>
using namespace std;
template<typename... Values> class tup;

template<>
class tup<>{};


template<class Head,typename... Tail>
class tup<Head,Tail...>:private tup<Tail...>{
	typedef tup<Tail...> inherited;
public:
	tup() {}
	tup(Head v, Tail... vtail) :m_head(v), inherited(vtail...) {}

	Head head() { return m_head; }
	inherited& tail() {return *this;}
protected:
	Head m_head;
};

int main() {
	
	tup<int, double, string> v(2, 3.23, "hehe" );
	cout << v.head() << " " << v.tail().head() << " " << v.tail().tail().head()<< endl;
	system("pause");
	return 0;

}

2 3.23 hehe
请按任意键继续. . .

以复合的形式实现简易tuple

#include<iostream>
#include<string>
using namespace std;
template<typename... Values> class tup {};

template<typename Head,typename...Tail>
class tup<Head, Tail...> {
	typedef tup<Tail...> composited;
public:
	tup(Head v, Tail... vtail) :m_head(v), m_tail(vtail...) {}
	Head head() {
		return m_head;
	}	
	composited tail() {
		return m_tail;
	}
protected:
	Head m_head;
	composited m_tail;
};

int main(){
	tup<int, double, string> v{ 2,3.2,"heh" };
	cout << v.tail().tail().head() << endl;
	cout << v.tail().head() << endl;
	cout << v.head() <<endl;
	system("pause");
	return 0;
}

heh
3.2
2
请按任意键继续. . .

2.auto 自动类型推导

list<string> c;
list<string>::iterator ite;
ite = find(c.begin(),c.end(),target);


list<string> c;
...
auto ite = find(c.begin(),c.end(),target);


list<string> c;
...
auto ite; //错误的
ite = find(c.begin(),c.end(),target);

auto主要用在比较复杂的类型上，让编译器自己去推到，比如lambda，容器的迭代器等

auto  l = [](int x)->int{return x + 1; };

3.ranged-base for

for（decl:coll){
	statement
}

注意有引用和没引用的区别，有引用的可以改变原来的值

vector<double> vec;
for(auto elem : vec){}//对原来值的copy
for(auto& elem :vec){}//对每一个元素的引用 修改elem也会改变原vector的值

4.nullptr and std::nullptr_t

c++11使用nullptr而不是0或NULL 来表示一个空指针
nullptr是一个新关键字。它会自动转换为每种指针类型，但不会转换为任何整数类型。它的类型为std :: nullptr_t，因此对于传递空指针的情况，甚至可以重载操作。

#include<cstdlib>
#include<iostream>
#include<string>
using namespace std;
void f(int) {
	cout << "void f(int)" << endl;
}
void f(void *) {
	cout << "void f(void *)" << endl;
}
int main() {
	f(0);// call void f(int)
	f(nullptr);//call void f(void *)
	f(NULL);//call void f(int) 会ambiguous
	system("pause");
	return 0;
}

void f(int)
void f(void *)
void f(int)
请按任意键继续. . .

从上述代码可以看出f(NULL)调用的是和f(int) ，所以会产生歧义，所以新标准要求我们使用nullptr来表示空指针。

5.Uniform Initialization

1.一致性初始化

C++11之前初始化时存在多个版本{}，（），=。，让使用者使用时比较混乱，C++11提供一种万用的初始化方法，就是使用大括号{}。

原理解析：当编译器看到大括号包起来的东西{t1,t2…tn}时，会生成一个initializer_list（initializer_list它其实是关联一个array<T,n>）。

1.调用函数（例如构造函数ctor）时该array内的元素可被编译器分解逐一传给函数；元素逐一分解传递给函数进行初始化 2. 但是如果调用函数自身提供了initializer_list参数类型的构造函数时，则不会分解而是直接传过去。直接整包传入进行初始化。所有的容器都可以接受这样的参数 
int i; // i 初始化为未定义值.
int j{}; // j 初始化为 0 （大括号可以用来设初值）
int * p; // p 初始化为未定义值.
int * q{}; // q 初始化为 0 （大括号可以用来设初值）
 
// 窄化（精度降低或造成数值变动）对大括号而言是不成立的.
int x0(3.4); // ok.
int x1 = 3.4; // ok.
int x2 { 3.4 }; // wrong.（不允许窄化数据处理，其实我的编译器只给警告）
int x3 = { 3.4 }; // wrong.（不允许窄化数据处理，其实我的编译器只给警告）
std::vector<int> v1 { 1, 2, 3 }; // ok.
std::vector<int> v2 { 1.1, 2.2, 3.3 }; // wrong.

{}初始化列表会对内置类型或自定义类型进行默认初始化，同时{}对数据更为严格，不允许类型的窄化。

2.initializer_list使用举例：

initializer_list是一个class（类模板），这个必须类型要一致，跟模板不定的参数类型相比，模板不定的参数类型可以都不一样。

initializer_list类似于容器的使用方法

class P {
public:
	//版本一
	P(int a, int b) {
		cout << "P(int a, int b) a=" << a << ",b=" << b << endl;
	}
	//版本二
	P(initializer_list<int> L) {
		cout << "P(initializer_list<int> L) ,values= ";
		for (auto i : L) {
			cout << i << " ";
			
		}cout << endl;
	}
};
int main() {
	P p(2, 3);
	P q{ 3,4 };
	P r{ 3,4,5 };
	P s = { 2,3 };
	//P t(2, 3, 4); //wrong

	system("pause");
	return 0;

}

P(int a, int b) a=2,b=3
P(initializer_list<int> L) ,values= 3 4
P(initializer_list<int> L) ,values= 3 4 5
P(initializer_list<int> L) ,values= 2 3

如果没有版本2，只有版本1。q和s不变，但是会分为两个参数传入。r将会不成立。
只要编译器遇到大括号里面有一些数，再传值的时候都会去生成一个initializer_list去处理；
initializer_list这个和前面一章节提到的不定参数模板相比，这个必须类型要一致，而后者则可以类型随意组合

3.源码分析：

1.initializer_list背后有array数组支撑，initializer_list它其实是关联一个array<T,n>

2.array是个指针，只是一个浅拷贝动作，比较危险，两个指针指向同一个内存

3、Initializer_list的源码定义（来自VS2017）

template<class _Elem>
	class initializer_list
	{	// list of pointers to elements
public:
	typedef _Elem value_type;
	typedef const _Elem& reference;
	typedef const _Elem& const_reference;
	typedef size_t size_type;

	typedef const _Elem* iterator;
	typedef const _Elem* const_iterator;

	constexpr initializer_list() noexcept
		: _First(nullptr), _Last(nullptr)
		{	// empty list
		}

	constexpr initializer_list(const _Elem *_First_arg,
		const _Elem *_Last_arg) noexcept
		: _First(_First_arg), _Last(_Last_arg)
		{	// construct with pointers
		}

	_NODISCARD constexpr const _Elem * begin() const noexcept
		{	// get beginning of list
		return (_First);
		}

	_NODISCARD constexpr const _Elem * end() const noexcept
		{	// get end of list
		return (_Last);
		}

	_NODISCARD constexpr size_t size() const noexcept
		{	// get length of list
		return (static_cast<size_t>(_Last - _First));
		}

private:
	const _Elem *_First;
	const _Elem *_Last;
	};

源码分析：根据侯捷老师所讲，编译器首先会调用constexpr initializer_list（）进行构造，但是在调用前initializer_list的背后已经关联好了array<T,_Size>数组，而函数中的_First和_Last会分别为指向array数组的起始元素和末尾的元素。（这里没有采用侯捷老师讲课视频中的源码，视频中那一版源码与VS2017提供的稍有不同，视频中，initializer_list类的成员函数不是_First和_Last这两个指针，而是一个iterator类的变量用来指向array数组的首元素和表示数组大小的size_type类型的变量，其实道理时一样的），需要注意的是这些元素都被包含在array数组中，initializer_list中没有包含这些元素，它提供的是指向array的指针，所以如果进行拷贝动作，只是两个initializer_list的指针指向同一个array，本质上是做的一个浅拷贝。还需要注意的是，size()的返回值为size_t,不是int,这里将_Last与_First相减，结果被static_cast转化为了size_t类型。

6.explicit

1. explicit for ctors taking one argument(构造函数一个实参)

class Complex {
public:
	int real, imag;
	Complex(int re, int im = 0) :real(re), imag(im) {}
	Complex operator+(const Complex& x) {
		return Complex(real + x.real, imag + x.imag);
	}
};
int main() {
	
	Complex c1(2, 3);
	Complex c2 = c1 + 5;//这里5会转变成Complex(5);
	cout << c2.real << " " << c2.imag << endl;
	system("pause");
	return 0;

}

7 3
请按任意键继续. . .

class Complex {
public:
	int real, imag;
	explicit Complex(int re, int im = 0) :real(re), imag(im) {}
	Complex operator+(const Complex& x) {
		return Complex(real + x.real, imag + x.imag);
	}
};

在前面加了个explicit 就会报错 无法进行类型转换
错误 二进制“+”: 没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)
错误 “Complex”: 没有合适的默认构造函数可用

2.explicit for ctors taking more than one argument（构造函数超过一个实参）

class P {
public:
	P(int a, int b) {
		cout << "P(int a, int b) " << endl;
	}
	 P(int a,int b, int c) {
		cout << "P(int a,int b, int c)" << endl;
	}
	
};
int main() {
	
	P p( 2, 3);
	P s = { 2,3,4 };
	system("pause");
	return 0;

}

P(int a, int b)
P(int a,int b, int c)
请按任意键继续. . .

class P {
public:
	P(int a, int b) {
		cout << "P(int a, int b) " << endl;
	}
	//加了个explicit
	 explicit P(int a,int b, int c) {
		cout << "P(int a,int b, int c)" << endl;
	}
	
};
int main() {
	
	P p( 2, 3);
	P s = { 2,3,4 }; //出错 “初始化”: 无法从“initializer list”转换为“P”		
	system("pause");
	return 0;

}

此时{}会形成一个initializer_list 不允许转换。

7.=default =delete

=default 只可以用于构造函数，拷贝构造，拷贝赋值，析构函数，移动构造，移动赋值构造上，不可以用于类的普通的函数上.
         
=delete  可以用于类的普通的函数上

如果我们定义了自己的构造函数，这时编译器就不会我们创建一个默认的构造函数，如果我们想要默认的构造函数就可以使用=default
如果我们不想要编译器为我们提供的默认拷贝构造，拷贝赋值，移动构造（&&） 移动赋值等，我们可以用=delete 来让编译器不在自己生成。

=default 用在普通函数身上 等于是个空函数。
=delete 用在普通函数身上会报错

一般c++的class分为带指针的和不带指针的，在不带指针的class我们可以使用编译器给的默认的这几个（big three/five)函数。如果有指针，我们就需要自己去设计我们的big three ，以为默认的copy赋值/构造是一个bit一个bit的copy，会导致浅拷贝。

8.Alias Template

9.using noexcept override final

using 几种用法

using namespace std;
using std::cout;
using INT = int;//别名

noexcept（不发出异常）

void foo() noexcept;
void foo() noexcept(true) //只有在里面的表达式为真时才不发出异常

如果异常不被处理，它就会往函数的调用者传递，如果一直没有被处理，就会一直往上传递，最终还没有被处理的话，就会被std::terminate（）处理，这个函数里面是调用std::abort（）。

在有&&（move） 的情况下，最好构造函数要有noexcept
在这里插入图片描述

override final

override主要时让编译器检查你对你要重写的函数是否有语法错误等
在这里插入图片描述
final 主要两种用法 1表示不能别继承 2不能被重写
在这里插入图片描述

10.decltype

可以解析出某个对象的类型

template<typename T1,typename T2>
decltype(x + y)add(T1 x, T2 y) {
	return x + y;
}

上面的代码会出错，需要将返回类型放在后面

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

11.Lambdas

是一种inline函数 通常作为一个参数或者local object
在这里插入图片描述
在这里插入图片描述

	int a = 10;
	auto l = [a](int x)mutable noexcept->decltype(x + a) {
		cout << ++a << endl;
		return a + x;
	};
	cout << l(2) << endl;
	cout << a << endl;

11
13
10

lambda没有默认构造函数和赋值构造函数。
在这里插入图片描述

楊xx
关注
专栏目录
【C/C++/QT/ 移植/导入Mavlink V2.0/Mavlink V1.0教程】
rbhhjjjhg的博客
09-05 2423
C/C++/QT/keil 移植/导入Mavlink V2.0/Mavlink V1.0教程 使用mavlink库
C++11 (C++2.0)笔记 一
jianfeng123123的博客
10-05 236
Variadic Templates 数量不定的模板参数 针对函数： 这种特性可以用来递归调用。这个递归的作用是把不定个数的参数 一 一 分解。 当我们在使用这个模板特性的时候一定要写一个处理最后一种情况的东西，在这里是一个函数 print() 。因为最后一次递归调用的时候参数为空。 c++11之后模板参数的尖括号可以写到一起了(编译器变得越来越智能) nullptr 和 nullptr_t auto Uniform Initia...
C++总结
yanxinrui0027的博客
11-15 626
Day01: 1.const 更严格的类型检查，C中可以暗度陈仓，通过指针来改一个const修饰的变量，但在C++中会被查出，等式左右两侧必须类型完全相同。 2.更严格的enum 3.表达式可以做左值。 4.布尔类型，其实是enum{true，false}。 5.C++ 不用指针 不用字符数组不用类型强转 6.所有字符串有关的用string定义,C中从键盘中读取字符到一个字符数组中，不
c++2.0新特性（c++11/14）
shayne000的博客
03-13 1145
语言部分 1. Variadic Templates可变参数模板 可以设计不同个数，不同类型的参数模板。 2. nullptr nullptr 出现的目的是为了替代 NULL。 在某种意义上来说，传统 C++ 会把 NULL、0 视为同一种东西，这取决于编译器如何定义 NULL，有些编译器会将 NULL 定义为 ((void*)0)，有些则会直接将其定义为 0。 nullptr 的类型为 null...
浅谈C++11(C++2.0)初始化列表
smallerxuan的博客
08-18 214
浅谈C++11(C++2.0)初始化列表 学过C++，我们知道对于C++，由于前向语法的支持，C++支持多种变量初始化的方式。 例如： int a = 10;  float b ={2.5};  double c (3.145);  vector {1,9,3,4}; 他们在语法上都是没有问题的，但语法上却并不具有一致性，虽然他们做的工作是一致的。 于是在C++11（即C++2.0）
错误 1 error C2679: 二进制“<<”: 没有找到接受“void”类型的右操作数的运算符(或没有可接受的转换)
热门推荐
Vincentlmeng的博客
03-20 1万+
void Get(const Key & k) { for (size_t i = 0; i < currentSize; ++i) { if (arr[i].key == k) return arr[i].value; } return Value(); }在主程序
c++2.0 srs/zlmediakit/docker教程
最新发布
10-16
c++2.0 srs/zlmediakit/docker教程
c++2.0编程工具
03-28
C++2.0编程工具是计算机编程领域的一个重要主题，特别是在历史的角度来看。这个标签“c++ 编译”暗示了我们将讨论的是关于C++语言的编译器和相关工具，这些工具在早期的计算机环境中，如DOS操作系统下被广泛使用。在...
编译Lvswin操作系统代码的Borland C++ v2.0/TC++ 3.0编译器
09-03
总结来说，Borland C++ v2.0和TC++ 3.0是两款在特定时期内极具影响力的C++编译器，它们在Lvswin3.1操作系统的开发过程中扮演了重要角色。通过这些编译器，开发者能够理解和学习到如何构建和优化复杂的操作系统代码，...
MATLAB Support for MinGW-w64 C/C++/Fortran Compiler
03-08
标题“MATLAB Support for MinGW-w64 C/C++/Fortran Compiler”涉及的主要知识点是MATLAB编程环境与MinGW-w64编译器的集成，以及对C、C++和Fortran语言的支持。 MATLAB是一款强大的数学计算软件，广泛用于科学计算...
JAVA第一阶段 编程练习(1)
weixin_45894818的博客
09-08 595
JAVA第一阶段 编程练习
c语言二进制数表示_C语言：数据类型与运算符
weixin_39668527的博客
11-20 1767
一、数据类型除void类型以外，基本的数据类型之前都可以加各种各类修饰符。在基本类型前加类型修饰符可以更加准确地对类型进行定义。1)signed———“无符号”之意，可以修饰int、char基本类型。注意：默认的int型定义为有符号整数，因此对int型使用signed是冗余的。signed的重要用途是在char类型默认为无符号时，使用signed修饰char，表示有符号字符型。2)unsigned...
C++类型和声明
weixin_45645281的博客
11-16 710
1.类型 1.1bool（布尔值）：布尔值，取true或者false，占1个字节。 void f(int a,int b) { bool b1={a==b}; //a=b,则b1为true；否则为false； } bool is_open(File*); bool greater(int a,int b) {return a>b; } bool b1=7; //b1为false； int i1=true; int i2 {ture}; //i1;i2均为1; void f(int i) { b
VS2017学习C++问题二（没有与这些操作数匹配的 “＜＜“ 运算符）
qq_951274168的博客
08-08 1万+
// 添加要在此处预编译的标头 #ifndef GZDEMO_H #define GZDEMO_H #pragma once #include <iostream> using namespace std; //函数定义 void input(int[], int[]); void print(int[], int[]); //函数实现 void input(int values[], int len) { if (len > 5) { cout << " 数组
Visual Studio, GCC, Clang, Intel 对 C++11 特性的支持一览表
黄沙百战穿金甲，不破楼兰终不还。
03-16 1429
距离我上次对C++11支持的不同编译器的比较已经有大半年了。这次我来根据这些预览版的编译器的文档来看下它们是如何堆砌起来的。 GCC的下个版本是4.8，以及Clang即将到来的版本是3.3 。如果你使用Visual Studio 2012，你可以安装2012年11月更新支持C++11额外特征的体验版CTP。 throwable 翻译于 2天前 0人顶
vs2012 二进制“==”: 没有找到接受“...”类型的左操作数的运算符(或没有可接受的转换)
brook0344的专栏
12-03 9288
二进制“==”: 没有找到接受“CSvrTableFrame”类型的左操作数的运算符(或没有可接受的转换) 把NULL==改为nullptr==
c++数据类型--文字常量、变量
vinep的专栏
02-17 2796
文字常量整型类型：char, short, int, longint i = 100; //缺省为intint i = 100u; //无符号整型int i = 100L; //long型int i = 100UL; //无符号long型表示方式：10进制， 八进制， 16进制int i = 20;       //10int i = 020;     //8int i = 0x20;  
LIBS += -lglib-2.0 -l/usr/lib/x86_64-linux-gnu/glib-2.0/include/glibconfig.h INCLUDEPATH += /usr/include/glib-2.0/详解
01-20
LIBS += -lglib-2.0 -l/usr/lib/x86_64-linux-gnu/glib-2.0/include/glibconfig.h 是一个在C/C++项目中使用的编译选项，用于GLib库和glibconfig.h头文件。 - `-lglib-2.0` 表示链接GLib库，GLib是一个通用的C语言库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值