首页 / C++ / 转载 C++11新特性学习
转载 C++11新特性学习
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了转载 C++11新特性学习,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含11936字,纯文字阅读大概需要18分钟。
内容图文
![转载 C++11新特性学习](/upload/InfoBanner/zyjiaocheng/1106/d5536273ccd44f95b013da94689983c7.jpg)
自己一直用的是C++98规范来编程,对于C++11只闻其名却没用过其特性。近期因为工作的需要,需要掌握C++11的一些特性,所以查阅了一些C++11资料。因为自己有C++98的基础,所以从C++98过渡到C++11并不算特别吃力,读了一些书籍后,算是对C++11有了个比较基础的理解,感觉程序员还是要经常保持新语言新特性的更新,现在 C++ 标准都出到C++17了!这篇文章就是对C++11一些常用新特性的一些总结,以C++98和 C++11在语法上的差异来突出C++11新特性的非凡优势。
一、新语法
1.自动类型推导auto
auto的自动推导,用于从初始化表达式中推断出变量的数据类型。
//C++98
int a = 10;
string s = "abc";
float b = 10.0;
vector<int> c;
vector<vector<int> > d;
map<int, string> m;
m[1] = "aaa";
map<int, string>::iterator it = m.begin();
//C++11auto a1 = 10; //a1为intauto s1 = "abc"; //s1为stringauto b1 = b;
auto c1 = c;
auto d1 = d;
auto e1 = ‘a‘;
int* x = &a1;
auto d1 = x;
auto m1 = m.begin();
auto x=1,y=2; //okauto i=1.j=3.14; //compile errordouble a2 = 3.144;
constauto a3 = a2; //const doubleauto a4 = a2; //doublevolatileint c2 = 3;
auto c3 = c2; //int
2.萃取类型decltype
decltype可以通过一个变量或表达式得到类型。
#include<iostream>
#include<vector>
using
namespace
std;
intadd(int a){
return ++a;
}
voidfun(int a){
cout << "call function: [int]\n" << endl;
}
voidfun(int *a){
cout << "call function: [int*]\n" << endl;
}
intmain(){
//C++11int aa = 10;
decltype(aa) bb = 11;
string ss = "hello intel";
decltype(ss) ss1 = "hello";
constvector<int> vec(1);
decltype(vec[0]) cc = 1;
decltype(0) dd = vec[0]; //dd是int类型decltype(add(1)) ee; //intint a[5];
decltype(a) ff; //int[5]//decltype(fun) gg; 无法通过编译,是个重载函数return0;
}
3.nullptr
空指针标识符nullptr是一个表示空指针的标识,他不是一个整数,这是与我们常用的NULL宏的区别。NULL只是一个定义为常整数0的宏,而nullptr是C++11的一个关键字,一个內建的标识符。
#include<iostream>
#include<vector>
using
namespace
std;
voidfun(int a){
cout << "call function: [int]\n" << endl;
}
voidfun(int *a){
cout << "call function: [int*]\n" << endl;
}
intmain(){
//C++11
fun(NULL); //call function: [int]
fun(nullptr); //call function: [int*]int* p = NULL;
fun(p); //call function: [int*]return0;
}
4.区间迭代range for
C++98和C++11在使用语法上的差异如下:
#include<iostream>
#include<vector>
using
namespace
std;
intmain(){
//C++98vector<int> vec(8, 1);
cout << "C++98 range for:" << endl;
for (vector<int>::iterator it = vec.begin(); it != vec.end(); it++)
{
cout << *it << endl;
}
//C++11cout << "C++11 range for:" << endl;
for (auto d : vec)
{
cout << d << endl;
}
return0;
}
值得指出的是,是否能够使用基于范围的for循环,必须依赖一些条件。首先,就是for循环迭代的范围是可确定的。对于类来说,如果该类有begin和end函数,那么for_each之间就是for循环迭代的范围。对于数组而言,就是数组的第一个和最后一个元素间的范围。其次,基于范围的for循环还要求迭代的对象实现+ + 和==等操作符。对于STL中的容器,如string、array、map等使用起来是不会有问题的。下面是C++11操作vector和数组的实践:
#include<iostream>
#include<vector>
using
namespace
std;
intmain(){
vector<int> vec(8, 1);
//C++11cout << "C++11 value range for:" << endl;
/*d非引用,修改d不会影响vector里的值*/for (auto d : vec) //d中存储的是vec中的值
{
d = 2;
}
for (auto d : vec)
{
cout << d << endl;
}
cout << "C++11 reference range for:" << endl;
/*当迭代变量d为引用时,vector里的值可以被修改*/for (auto &d : vec)
{
d = 2;
}
for (auto d : vec)
{
cout << d << endl;
}
//数组for_eachchar arr[] = {‘a‘,‘b‘,‘c‘,‘d‘};
for (auto &d : arr)
{
d -= 32;
}
for (auto d : arr)
{
cout << d << endl;
}
//遍历二维数组,注意迭代变量row必须为引用。如果你想用 range for 的方法,来遍历更高维的数组 (dim > 2),那么你只需要:除了最内层循环之外,其他所有外层循环都加入 ‘&‘ 即可。int array2[5][5] = {0};
for (auto &row : array2)
for (auto col : row)
cout << col << endl;
return0;
}
5.返回类型后置语法
先看下面这个例子,编译器在推导decltype(t1+t2)时表达式中t1和t2都未声明,所以编译失败。
#include<iostream>
#include<vector>
using
namespace
std;
template<classT1, classT2>
decltype(t1 + t2) sum(T1t1, T2t2)
{return t1 + t2;
}
intmain(){
auto total = sum(1, 2);
cout << total << endl;
return0;
}
所以C++11引入新语法,即把函数的返回值移至参数声明之后,复合符号->decltype(t1+t2)被称为追踪返回类型。而原本的函数返回值由auto占据。
#include<iostream>
#include<vector>
using
namespace
std;
template<classT1, classT2>
autosum(T1t1, T2t2) ->decltype(t1+t2)
{return t1 + t2;
}
intmain(){
auto total = sum(1, 2);
cout << total << endl;
return0;
}
6.final和override
struct
B
{
virtual
void
f1
(int)
const
;
virtualvoidf2();
voidf3();
};
structD1 :public B
{
voidf1(int)const override; //okvoidf2(int) override; //error,B中没有形如f2(int)的函数voidf3() override; //error,f3不是虚函数voidf4() override; //error,B中无f4函数
};
structD2 :public B
{
voidf1(int)const final; //不许后续的其他类覆盖
};
structD3 :public D2
{
voidf2();
voidf1(int)const; //error,final函数不可覆盖
};
final还可以用于防止继承的发生
class
NoDerived
final
{
};
classBad :NoDerived //NoDerived不可做基类
{
};
classBase
{
};
classLastfinal :Base
{
};
classBad2 :Last //Last不可做基类
{
};
7.=default和=delete
对于 C++ 的类,如果程序员没有为其定义特殊成员函数,那么在需要用到某个特殊成员函数的时候,编译器会隐式的自动生成一个默认的特殊成员函数,比如拷贝构造函数,或者拷贝赋值操作符。
C++11允许我们使用=default来要求编译器生成一个默认构造函数,也允许我们使用=delete来告诉编译器不要为我们生成某个默认函数
class
B
{
B() = default; //显示声明使用默认构造函数
B(const B&) = delete; //禁止使用类对象之间的拷贝
~B() = default; //显示声明使用默认析构函数
B& operator=(const B&) = delete; //禁止使用类对象之间的赋值
B(int a);
};
8.lambda表达式
简单来说,Lambda函数也就是一个函数(匿名函数),它的语法定义如下:
[capture](parameters) mutable ->return-type{statement}
- [=,&a,&b]表示以引用传递的方式捕捉变量a和b,以值传递方式捕捉其它所有变量;
- [&,a,this]表示以值传递的方式捕捉变量a和类的this指针,引用传递方式捕捉其它所有变量。
#include<iostream>
using
namespace
std;
intmain(){
auto f = []() {cout << "hello world!" << endl; };
f(); //hello world!int a = 123;
auto f1 = [a] { cout << a << endl; };
f1(); //123auto f2 = [&a] {cout << a << endl; };
a = 789;
f2(); //789//隐式捕获:让编译器根据函数体中的代码来推断需要捕获哪些变量auto f3 = [=] {cout << a << endl; };
f3(); //789auto f4 = [&] {cout << a << endl; };
a = 990;
f4(); //990auto f5 = [](int a, int b)->int {return a + b; };
printf("%d\n", f5(1, 2)); //3return0;
}
lambda表达式在C++下的应用,排序
#include<stdio.h>
#include<algorithm>
#include<vector>
using
namespace
std;
voidprint(char arr[], int len){
for (int i = 0; i < len; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
boolcmp(char a, char b){
if (a > b)
returntrue;
elsereturnfalse;
}
intmain(){
//c++98char arr1[] = { 2,5,2,1,5,89,36,22,89 };
int len = sizeof(arr1) / sizeof(char);
sort(arr1, arr1 + len, cmp);
print(arr1, len);
//c++11char arr2[] = { 2,5,2,1,5,89,36,22,89 };
int len2 = sizeof(arr2) / sizeof(char);
sort(arr2, arr2 + len2, [](char a, char b)->bool {return a > b; });
print(arr2, len2);
return0;
}
9.std::move
std::move是为性能而生,通过std::move,可以避免不必要的拷贝操作。std::move是将对象的状态或者所有权从一个对象转移到另一个对象,只是转移,没有内存的搬迁或者内存拷贝。
#include<iostream>
#include<utility>
#include<vector>
#include<string>
int
main
()
{
std::string str = "Hello";
std::vector<std::string> v;
//调用常规的拷贝构造函数,新建字符数组,拷贝数据
v.push_back(str);
std::cout << "After copy, str is \"" << str << "\"\n"; //After move, str is "Hello"//调用移动构造函数,掏空str,掏空后,最好不要使用str
v.push_back(std::move(str));
std::cout << "After move, str is \"" << str << "\"\n"; //After move, str is ""std::cout << "The contents of the vector are \"" << v[0]
<< "\", \"" << v[1] << "\"\n"; //The contents of the vector are "Hello", "Hello"
}
二、STL新内容
1.std::array
-
使用 std::array保存在栈内存中,相比堆内存中的 std::vector,我们就能够灵活的访问这里面的元素,从而获得更高的性能;同时正式由于其堆内存存储的特性,有些时候我们还需要自己负责释放这些资源。
-
使用std::array能够让代码变得更加现代,且封装了一些操作函数,同时还能够友好的使用标准库中的容器算法等等,比如 std::sort。
std::array 会在编译时创建一个固定大小的数组,std::array 不能够被隐式的转换成指针,使用 std::array 很简单,只需指定其类型和大小即可:
#include<stdio.h>
#include<algorithm>
#include<array>
void
foo
(int* p)
{
}
intmain(){
std::array<int, 4> arr = {4,3,1,2};
foo(&arr[0]); //OK
foo(arr.data()); //OK//foo(arr); //wrongstd::sort(arr.begin(), arr.end()); //排序return0;
}
2.std::forward_list
std::forward_list 使用单向链表进行实现,提供了 O(1) 复杂度的元素插入,不支持快速随机访问(这也是链表的特点),也是标准库容器中唯一一个不提供 size() 方法的容器。当不需要双向迭代时,具有比 std::list 更高的空间利用率。
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string>
#include<forward_list>
int
main
()
{
std::forward_list<int> list1 = { 1, 2, 3, 4 };
//从前面向foo1容器中添加数据,注意不支持push_back
list1.pop_front(); //删除链表第一个元素
list1.remove(3); //删除链表值为3的节点
list1.push_front(2);
list1.push_front(1);
list1.push_front(14);
list1.push_front(17);
list1.sort();
for (auto &n : list1)
{
if (n == 17)
n = 19;
}
for (constauto &n : list1)
{
std::cout << n << std::endl; //1 2 2 4 14 19
}
return0;
}
3.std::unordered_map和std::unordered_set
无序容器中的元素是不进行排序的,内部通过 Hash 表实现,插入和搜索元素的平均复杂度为 O(constant),在不关心容器内部元素顺序时,能够获得显著的性能提升。
C++11 引入了两组无序容器:std::unordered_map/std::unordered_multimap 和 std::unordered_set/std::unordered_multiset。
下面给出unordered_map和unordered_set的使用方法。
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string>
#include<unordered_map>
#include<unordered_set>
void
foo
(int* p)
{
}
intmain(){
//unordered_map usagestd::unordered_map<std::string, int> um = { {"2",2},{"1",1},{"3",3} };
//遍历for (constauto &n : um)
{
std::cout << "key:" << n.first << " value:" << n.second << std::endl;
}
std::cout << "value:" << um["1"] << std::endl;
//unordered_set usagestd::unordered_set<int> us = { 2,3,4,1};
//遍历for (constauto &n : us)
{
std::cout << "value:" << n << std::endl;
}
std::cout << "value:" << us.count(9) << std::endl; //判断一个数是否在集合内,1存在0不存在std::cout << "value:" << *us.find(1) << std::endl; //查找一个特定的数是否在集合内,找到就返回该数的迭代器位置return0;
}
三、智能指针
1. std::shared_ptr
shared_ptr使用引用计数,每一个shared_ptr的拷贝都指向相同的内存。每使用他一次,内部的引用计数加1,每析构一次,内部的引用计数减1,减为0时,删除所指向的堆内存。shared_ptr内部的引用计数是安全的,但是对象的读取需要加锁。
#include<stdio.h>
#include<memory>
#include<iostream>
int
main
()
{
//auto ptr = std::make_shared<int>(10);std::shared_ptr<int> ptr(newint(10));
std::shared_ptr<int> ptrC(ptr);
auto ptr2 = ptr;
{
auto ptr3 = ptr2;
std::cout << "pointer1.use_count() = " << ptr.use_count() << std::endl; //4std::cout << "pointer2.use_count() = " << ptr2.use_count() << std::endl; //4
}
std::cout << "pointer1.use_count() = " << ptr.use_count() << std::endl; //3std::cout << "pointer2.use_count() = " << ptr2.use_count() << std::endl; //3int *p = ptr.get(); //获取原始指针std::cout << "pointer1.use_count() = " << ptr.use_count() << std::endl; //3std::cout << "pointer2.use_count() = " << ptr2.use_count() << std::endl; //3return0;
}
3 2. std::unique_ptr
std::unique_ptr 是一种独占的智能指针,它禁止其他智能指针与其共享同一个对象,从而保证代码的安全:
#include <stdio.h>
#include <memory>
#include <iostream>
int main()
{
std::unique_ptr<int> ptr(new int(10));
//auto ptr2 = ptr; //非法//虽说unique_ptr是不可复制的,但我们可以使用std::move将其独占权转移到其他的unique_ptr
auto ptr2(std::move(ptr));
std::cout << *ptr2 << std::endl;
return0;
}
3. std::weak_ptr
先观察下面的代码,如果我们在类father中使用的是shared_ptr
father !
son !
以上问题就是shared_ptr的环形引用问题。为了避免shared_ptr的环形引用问题,需要引入一个弱引用weak_ptr, weak_ptr是为了配合shared_ptr而引入的一种智能指针,弱引用不会引起引用计数增加,它更像是shared_ptr的一个助手而不是智能指针,因为它不具有普通指针的行为,没有重载operator*和->,它的最大作用在于协助shared_ptr工作,像旁观者那样观测资源的使用情况.
#include<iostream>
#include<memory>
using
namespace
std;
classfather;classson;classfather {public:
father() {
cout << "father !" << endl;
}
~father() {
cout << "~~~~~father !" << endl;
}
voidsetSon(shared_ptr<son> s){
son = s;
}
private:
//shared_ptr<son> son;
weak_ptr<son> son; // 用weak_ptr来替换
};
classson {public:
son() {
cout << "son !" << endl;
}
~son() {
cout << "~~~~~~son !" << endl;
}
voidsetFather(shared_ptr<father> f){
father = f;
}
private:
shared_ptr<father> father;
};
voidtest(){
shared_ptr<father> f(new father());
shared_ptr<son> s(new son());
f->setSon(s);
s->setFather(f);
}
intmain(){
test();
return0;
}
输出:
father !
son !
~~~~~~son !
~~~~~father !
原文:https://www.cnblogs.com/xjyxp/p/11101908.html
内容总结
以上是互联网集市为您收集整理的转载 C++11新特性学习全部内容,希望文章能够帮你解决转载 C++11新特性学习所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。