目录
新增加容器--静态数组array、forward_list以及unordered系列
列表初始化
｛｝初始化
在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：
struct Point{
int _x;
int _y;
};
int main(){
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
return 0;
}
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自 定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。
struct Point{
int _x;
int _y;
};
int main(){
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 };
return 0;
}
std::initializer_list
std::initializer_list使用场景：
std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就有增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator= 的参数，这样就可以用大括号赋值。
将大括号的初始化传递给一个对象，将这个对象类型识别为initializer_list。
vector、list、map等容器也增加了这样的构造。比如vector的C++11里边的新增的构造函数。
int main() {
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int> v2 = { 1,2,3,4 };
vector<int> v3 = { 1,2,3,4,5,6,7,8 };
list<int> lt1 = { 1,2,3,4,5 };
pair<string, string> kv("left", "左边");
map<string, string> dict = { {"insert","插入"} ,{"sort","排序"},kv, make_pair("list","列表") };
initializer_list<int> ilt = { 1,2,3,4,5,6,7,8 };
return 0;
}
变量类型推导
auto
auto其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。在模板中使用特别方便。
int main(){
int i = 10;
auto p = &i;
auto pf = strcpy;
cout << typeid(p).name() << endl;
cout << typeid(pf).name() << endl;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
return 0;
}
decltype
关键字decltype将变量的类型声明为表达式指定的类型。
int main() {
const int x = 1;
double y = 2.2;
list<int> lt = { 1,2,3 };
list<int>::iterator it = lt.begin();
//cout << typeid(it).name() << endl;
decltype(x) b = 2;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p; // p的类型是int*
return 0;
}适合场景：要定义一个auto推导的类型的变量的时候或者类模板参数很长的时候。
nullptr
由于C++中NULL被定义成字面量0，这样就可能会带来一些问题，因为0既能指针常量，又能表示 整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
范围for循环
范围for的底层是迭代器。使用如下：
int a[] = {7,4,1,8,5,2,9,6,3};
for(auto e : a){
cout << e << " ";
}final和override
final：修饰类。加了final就不能被继承；修饰函数，加了final之后就不能被重写。
override：检查能否被重写。
default：强制生成默认函数
class Person {
public:
Person() = default;
Person(const char* name, int age)
:_name(name)
, _age(age)
{}
Person(const Person& p)
:_name(p._name)
, _age(p._age)
{}
private:
hzp::string _name;
int _age = 0;
};
int main(){
Person p;
return 0;
}delete：禁止生成默认函数
class A{
public:
A() = default;
/*void f(){
A copy = *this;
}*/
A(const A& a) = delete;
};智能指针
新增加容器--静态数组array、forward_list以及unordered系列
array是一个静态数组。提供了支持迭代器、对于越界的检查。
forward_list是一个单链表。
unordered系列参考以下链接unordered系列
默认成员函数控制
默认成员函数 原来C++类中，有6个默认成员函数：
1. 构造函数 2. 析构函数 3. 拷贝构造函数 4. 拷贝赋值重载 5. 取地址重载 6. const 取地址重载
最后重要的是前4个，后两个用处不大。默认成员函数就是我们不写编译器会生成一个默认的。 C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：
如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任 意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类 型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造， 如果实现了就调用移动构造，没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中 的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内 置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋 值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造 完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
C++11允许在类定义时给成员变量初始缺省值，默认生成构造函数会使用这些缺省值初始化。
可变参数模板
下面就是一个基本可变参数的函数模板
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数 包”，它里面包含了0到N（N>=0）个模版参数。
获取参数包args中的每个参数
// 递归终止函数
template <class T>
void ShowList(const T& t){
cout << typeid(t).name() << ":" << t << endl << endl;
}
// 解析并打印参数包中每个参数的类型及值
template <class T, class ...Args>
void ShowList(T val, Args... args){
cout << typeid(val).name() << ":" << val << endl;
ShowList(args...);
}
int main(){
ShowList(1);
ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}STL容器中的empalce相关接口函数
emplace接口支持可变参数。
右值引用
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
int main(){
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;
}
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引 用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
区别左值和右值的关键：左值可以取地址，但是右值不能取地址。
int main(){
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);
// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
return 0;
}左值&右值的交叉引用
左值引用总结：
1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
右值引用总结：
1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。
int main() {
// 以下几个都是常见的右值
double x = 1.1, y = 2.2;
10;
x + y;
fmin(x, y);
// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;
// 左值引用能否引用右值 -- 不能直接引用，但是const左值引用可以引用右值
// void push_back(const T& x)
const int& r1 = 10;
const double& r2 = x + y;
const double& r3 = fmin(x, y);
// 右值引用能否引用左值 -- 不能直接引用，但是可以右值引用可以引用move以后左值
int*&& rr1 = move(p);
int&& rr2 = move(*p);
int&& rr3 = move(b);
const int&& rr4 = move(c);
return 0;
}需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说给右值取别名后，这个别名就变成了左值。
右值引用使用场景
左值引用的场景1：做参数。当使用传值传参的时候，对于自定义类型可能会引发深拷贝，而深拷贝的代价很大。使用左值引用就能完美解决问题。
左值引用的场景2：做返回值。对于出了函数作用域对象还在的时候（比如string的operator+=），使用左值引用能够解决问题。但是，当除了作用域对象不在（比如string的operator+），需要析构的时候，就只能使用传值返回了，就会再次发生深拷贝。
针对左值引用的场景2解决得并不完美，便出现了右值引用。
对于编译器的优化说明
ps:上图右边的文字的后半段，可以先看完移动构造和移动赋值再理解。
移动构造&移动赋值
下图对于自定义string的operator+的场景进行了说明：
移动构造就是将原先对象的资源进行转移，并原对象的资源并没有发生析构，它的资源只是被转移到另外的“外壳”中了。
处理移动构造，C++11还增加了移动赋值；
完美转发
模板中的&&（万能引用）
模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就使用完美转发。
完美转发的应用场景：
lambda表达式
1. lambda表达式各部分说明
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda 函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意： 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为 空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
2. 捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。 [var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针
注意：
a. 父作用域指包含lambda函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量 [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
d. 在块作用域以外的lambda函数捕捉列表必须为空。
e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者 非局部变量都 会导致编译报错。
f. lambda表达式之间不能相互赋值，即使看起来类型相同
int main(){
// 实现一个两个数相加的lambda
auto add = [](int a, int b)->int{return a + b; };
cout << add1(1, 2) << endl;
return 0;
}运行以下代码，查看汇编；
class Rate{
public:
Rate(double rate) : _rate(rate)
{}
double operator()(double money, int year){
return money * _rate * year;
}
private:
double _rate;
};
int main(){
// 函数对象
double rate = 0.49;
Rate r1(rate);
r1(10000, 2);
// lamber 底层原理，其实是被处理成一个lambda_uuid的一个仿函数类
auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
r2(10000, 2);
// lamber
auto r3 = [=](double monty, int year)->double {return monty * rate * year; };
r3(10000, 2);
return 0;
}
从汇编中类比第一条调用仿函数的过程可以观察出，lambda表达式的底层被处理成了一个仿函数类。
包装器
template<class F, class T>
T useF(F f, T x){
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i){
return i / 2;
}
struct Functor{
double operator()(double d){
return d / 3;
}
};
int main(){
// 函数指针
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式对象
cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;
return 0;
}执行结果：
但是应对某些场景的时候（比如事件响应），我们有时侯只希望实例化成为一份，这里就需要使用包装器（对不同的可调用对象进行包装）。包装器其实是一个类模板，其原型如下：
包装器的使用
int f(int a, int b){
return a + b;
}
struct Functor{
public:
int operator() (int a, int b){
return a + b;
}
};
class Plus{
public:
static int plusi(int a, int b){
return a + b;
}
double plusd(double a, double b){
return a + b;
}
};
int main() {
function<int(int, int)> f1 = f;//普通函数
f1(1, 2);//这里的f1就是一个包装器的对象
function<int(int, int)> f2 = Functor();//仿函数
f2(1, 2);
function<int(int, int)> f3 = Plus::plusi;//类成员静态函数
f3(1, 2);
function<double(Plus, double, double)> f4 = &Plus::plusd;//类成员非静态函数
f4(Plus(), 1.1, 2.2);
return 0;
}bind
bind的作用是调整对应的参数（顺序、个数）。
调整参数顺序
int Div(int a, int b){
return a / b;
}
using namespace placeholders;
int main(){
int x = 2, y = 10;
cout << Div(x, y) << endl;
// 调整顺序
// _1 _2.... 定义在placeholders命名空间中，代表绑定函数对象的形参，
// _1，_2...分别代表第一个形参、第二个形参...
bind(Div, _1, _2);
auto bindFunc1 = bind(Div, _1, _2);
function<int(int, int)> bindFunc2 = bind(Div, _2, _1);
cout << bindFunc1(x, y) << endl;
cout << bindFunc2(x, y) << endl;
return 0;
}运行结果：
调整参数个数
int Div(int a, int b){
return a / b;
}
int Plus(int a, int b){
return a + b;
}
int Mul(int a, int b, double rate){
return a * b * rate;
}
class Sub{
public:
int sub(int a, int b){
return a - b;
}
};
using namespace placeholders;
int main(){
// 调整个数, 绑定死固定参数
function<int(int, int)> funcPlus = Plus;
//function<int(Sub, int, int)> funcSub = &Sub::sub;//原本这里需要三个参数
function<int(int, int)> funcSub = bind(&Sub::sub, Sub(), _1, _2);//这里将Sub()，写死了，funcSub传入第一个形参和第二个形参就行了
function<int(int, int)> funcMul = bind(Mul, _1, _2, 1.5);//这里将Mul的第三个参数写死了就为1.5，然后funcMul传入剩下的第一个形参和第二个形参就行了
map<string, function<int(int, int)>> opFuncMap =
{
{ "+", Plus},
{ "-", bind(&Sub::sub, Sub(), _1, _2)}
};
cout << funcPlus(1, 2) << endl;
cout << funcSub(1, 2) << endl;
cout << "Mul--->" << funcMul(2, 2) << endl;
cout << opFuncMap["+"](1, 2) << endl;
cout << opFuncMap["-"](1, 2) << endl;
return 0;
}运行结果：
实现静态成员函数和普通成员函数
void BindTestClass::StaticFun(const string &str, int age)
{
cout << "this is static function" << endl;
cout << "name is " << str << endl;
cout << "age is " << age << endl;
}
void BindTestClass::MemberFun(const string &job, int score)
{
cout << "this is member function" << endl;
cout << "name is " << name << endl;
cout << "age is " << num << endl;
cout << "job is " << job << endl;
cout << "score is " << score << endl;
}通过bind绑定静态成员函数和普通成员函数
//绑定类的静态成员函数,加不加&都可以
// auto staticbind = bind(BindTestClass::StaticFun, placeholders::_1, 33);
auto staticbind = bind(&BindTestClass::StaticFun, placeholders::_1, 33);
staticbind("zack");
//绑定普通成员函数
BindTestClass bindTestClass(33, "zack");
// 绑定类的成员函数,一定要传递对象给bind的第二个参数，可以是类对象，也可以是类对象的指针
// 如果要修改类成员，必须传递类对象的指针
auto memberbind = bind(&BindTestClass::MemberFun, &bindTestClass, placeholders::_1, placeholders::_2);
memberbind("coder", 100);
auto memberbind2 = bind(&BindTestClass::MemberFun, placeholders::_3, placeholders::_1, placeholders::_2);
memberbind2("coder", 100, &bindTestClass);
//绑定类成员时，对象必须取地址
auto numbind = bind(&BindTestClass::num, placeholders::_1);
std::cout << numbind(bindTestClass) << endl;直接用function对象接受bind返回的结果
// function接受bind返回的函数
function< void(int, string)> funcbind = bind(globalFun2, "zack", placeholders::_1, 100, placeholders::_2);
funcbind(33, "engineer");
// function接受bind 成员函数
function< void(string, int)> funcbind2 = bind(&BindTestClass::MemberFun, &bindTestClass, placeholders::_1, placeholders::_2);
funcbind2("docker", 100);
function< void(string, int, BindTestClass *)> funcbind3 = bind(&BindTestClass::MemberFun, placeholders::_3, placeholders::_1, placeholders::_2);
funcbind3("driver", 100, &bindTestClass);
// function 直接接受成员函数,function的模板列表里第一个参数是类对象引用
function< void(BindTestClass &, const string &, int)> functomem = BindTestClass::MemberFun;
functomem(bindTestClass, "functomem", 88);
// function 绑定类的静态成员函数
function< void(const string &)> funbindstatic = bind(&BindTestClass::StaticFun, placeholders::_1, 33);
funbindstatic("Rolis");更多时候，bind和function是搭配起来使用的。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
