{}列表初始化
C++11扩大了用大括号括起的列表(初始化列表)的使用范围,使其可用于所有的内置类型和用户自定义的类型,使用初始化列表时,可添加等号(=),也可不添加。
int x1 = 1;
int x2{ 2 };
int array1[]{ 1, 2, 3, 4, 5 };
int array2[5]{ 0 };
Point p{ 1, 2 };
// C++11中列表初始化也可以适用于new表达式中
int* pa = new int[4]{ 0 };
initializer_list
STL容器同样支持:
vector<int> a { 1, 2, 3, 4, 5 };
list<int> b { 1, 2, 3, 4, 5 };
a = {10, 20, 30};
这是因为所有的容器都重载了initializer_list
构造函数和initializer_list
赋值运算符重载:
initializer_list参考文档
使用map
通过initializer_list
进行赋值时,需要注意key的const
属性
声明
auto
在C++98中auto
是一个存储类型的说明符,表明变量是局部自动存储类型,但是局部域中定义局部的变量默认就是自动存储类型,所以auto
就没什么价值了。C++11中废弃auto
原来的用法,将其用于实现自动类型腿断。这样要求必须进行显示初始化,让编译器将定义对象的类型设置为初始化值的类型。
int i = 10;
auto p = &i;
auto pf = strcpy;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
decltype
关键字decltype
将变量的类型声明为表达式指定的类型
const int x = 1;
double y = 2.2;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p; // p的类型是int*
decltype
跟auto
不一样,auto
是根据结果来推导,decltype
是根据变量类型来推导。
nullptr
由于C++中NULL被定义成字面量0,这样就可能回带来一些问题,因为0既能指针常量,又能表示整形常量。所以出于清晰和安全的角度考虑,C++11中新增了nullptr,用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
STL中一些变化
都支持了initializer_list
的初始化,同时新增了几个容器:
用橘色圈起来是C++11中的一些几个新容器
array: 为了规范数组的使用,同时加强了越界检查。
forward_list: 单向链表
右值引用
左值引用和右值引用的区别
注意:
右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,且可
以取到该位置的地址。即:右值引用有左值的性质
int&& rr1 = 10;
rr1 = 20;
cout << &rr1 << endl;
左值引用与右值引用比较
左值引用总结:
- 左值引用只能引用左值,不能引用右值。
- 但是const左值引用既可引用左值,也可引用右值。
const int& ra3 = 10;
右值引用总结:
- 右值引用只能右值,不能引用左值。
- 但是右值引用可以move以后的左值。
int&& r3 = std::move(a);
移动构造和移动赋值
左值引用的使用场景:
- 做参数(减少拷贝,输出型参数)
- 做返回值(减少拷贝,引用返回修改对象(
operator[]
))
缺点:
右值引用就是用来解决上面的缺点的:
通过右值引用传参的方式,重载构造函数。对于自定义类型的右值,可以看作是将亡值,可以直接换取它的资源。
移动构造:
// 移动构造
string(string&& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
cout << "string(string&& s) -- 移动语义" << endl;
swap(s);
}
移动赋值:
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动语义" << endl;
swap(s);
return *this;
}
所以在使用的时候不能随便对左值进行move,move之后左值会变成右值,资源也可以被转移。
所有的容器都增加了移动构造和移动赋值,同时插入接口也有右值版本。
模板的万能引用和完美转发
void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// 模板中的&&不代表右值引用,而是万能引用,其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力,
// 但是引用类型的唯一作用就是限制了接收的类型,后续使用中都退化成了左值,
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
Fun(t);
}
int main()
{
PerfectForward(10); // 右值
int a;
PerfectForward(a); // 左值
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
return 0;
}
完美转发:让引用类型保持原有属性
template<typename T>
void PerfectForward(T&& t)
{
Fun(std::forward<T>(t));
}
类的新功能
新的类的成员函数
原来C++类中,有6个默认成员函数:
- 构造函数
- 析构函数
- 拷贝构造函数
- 拷贝赋值重载
- 取地址重载
- const 取地址重载
在C++11 新增了两个:移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下:
-
如果你没有自己实现移动构造函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,自定义类型成员,则需要看这个成员是否实现移动构造,如果实现了就调用移动构造,没有实现就调用拷贝构造。
-
如果你没有自己实现移动赋值重载函数,且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个,那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数,对于内置类型成员会执行逐成员按字节拷贝,自定义类型成员,则需要看这个成员是否实现移动赋值,如果实现了就调用移动赋值,没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
-
如果你提供了移动构造或者移动赋值,编译器不会自动提供拷贝构造和拷贝赋值
强制生成和删除默认成员函数
强制生成:
Person(Person&& p) = default;
删除:
Person(const Person& p) = delete;
可变参数模板
// Args是一个模板参数包,args是一个函数形参参数包
// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
通过递归函数展开参数包:
// 递归终止函数
template <class T>
void ShowList(const T& t)
{
cout << t << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)
{
cout << value <<" ";
ShowList(args...);
}
逗号表达式展开参数包:
template <class T>
void PrintArg(T t)
{
cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (PrintArg(args), 0)... };
cout << endl;
}
emplace 和 insert
emplace
使用的是将可变参数模板。
// 我们会发现其实差别也不到,emplace_back是直接构造了,push_back
// 是先构造,再移动构造,其实也还好。
std::list< std::pair<int, bit::string> > mylist;
mylist.emplace_back(10, "sort");
mylist.emplace_back(make_pair(20, "sort"));
mylist.push_back(make_pair(30, "sort"));
mylist.push_back({ 40, "sort"});
对比insert接口最大的效率优化在与直接构造和减少拷贝构造。
lambda表达式
lambda表达式语法:
lambda表达式书写格式:
[capture-list] (parameters) mutable -> return-type { statement}
注意:
lambda
表达式实际上是一个匿名函数,可以通过auto
自动推到类型存储起来。
捕捉列表声明:
void (*PF)();
int main()
{
auto f1 = []{cout << "hello world" << endl; };
auto f2 = []{cout << "hello world" << endl; };
// 此处先不解释原因,等lambda表达式底层实现原理看完后,大家就清楚了
//f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个lambda表达式拷贝构造一个新的副本
auto f3(f2);
f3();
// 可以将lambda表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}
函数对象与lambda表达式
函数对象,又称为仿函数,即可以想函数一样使用的对象,就是在类中重载了operator()
运算符的类对象。
lambda表达式在底层实现上按照函数对象的方式实现。即:如果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()
。
在底层lambda
是lambda_uuid
形式。
包装器
将不同的类型按照同意的形式进行包装,简化代码。
function包装器
使用方法:
// 函数名
std::function<double(double)> func1 = f;
// 函数对象
std::function<double(double)> func2 = Functor();
// lamber表达式
std::function<double(double)> func3 = [](double d)->double{ return d /
4; };
bind
std::bind 函数定义在头文件中,是一个函数模板,它就像一个函数包装器(适配器),接受一个可调用对象(callable object),生成一个新的可调用对象来“适应”原对象的参数列表。
// 原型如下:
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
调用bind
的一般形式:
auto newCallable = bind(callable,arg_list);
调整参数顺序:
bind
可以调整函数的参数顺序:
int sub(int a, int b)
{
return a - b;
}
auto func = bind(sub, placeholders::_2, placeholders::_1);
// func = b - a;
调整参数个数:
调用成员函数时需要指定成员函数,可以通过bind
绑定成员函数。
Sub s;
// 绑定成员函数
std::function<int(int, int)> func = std::bind(&Sub::sub, s,
placeholders::_1, placeholders::_2);
// func = s->sub;