目录
接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧
一：使用列表初始化
1.统一使用{}初始化(对于内置类型和自定义类型)
在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;
};
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{
cout << "Date(int year, int month, int day)" << endl;
}
private:
int _year;
int _month;
int _day;
};
//c++11支持一切使用列表初始化
int main()
{
int x1 = { 1 };
int array1[] = { 1, 2, 3, 4, 5 };
Point p = { 1, 2 };
Date d1={ 2022, 1, 2 };//多参数的构造函数的隐式类型转换
const Date& d2 = { 2024,8,31 };
//c++11支持可以不加=
int x2{1};
int array2[]{ 1, 2, 3, 4, 5 };
Point p1{ 1, 2 };
Date d3{ 2022, 1, 2 };
}
2.std::initializer_list(对于容器的多值构造)
对于vector,list等容器支持多个值来构造初始化
对于这里的Date类是多参数的构造函数的隐式类型转换，必须跟对应构造函数的参数个数匹配，而对于这里的vector,list等容器则是使用了initializer_list的构造函数
对于这里的initializer_list则是c++11新引入的一个类型，查阅官方文档介绍得
c++11在这里把列表的值识别为一个initializer_list的对象，每个值的类型都是initializer_list
在底层方面
对于上述的多值构造，实际上是用迭代器遍历这个initializer_list，将每个值插入到vector等容器中或者使用对应的迭代器区间来构造
对于这里的列表初始化和 initializer_list构造结合起来使用的优秀例子为
二：decltype和nullptr
1.关键字decltype将变量的类型声明为表达式指定的类型
int i = 1;
map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//map<string, string>::iterator it = dict.begin();
auto it = dict.begin();
cout << typeid(i).name() << endl;
auto k = i;
vector<decltype(it)> v;
decltype(it) it1;
对于typeid().name()来获取的类型是以字符串形式获取到的，获取到的这个类型不能用来创建变量或者使用的，此时我们就可以使用auto来创建变量
但auto不能做参数，这是就得用decltype(变量)来推导对象的类型，这个类型是可以用来做模板实参或者再定义对象
2.nullptr
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示
整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针
三：右值引用和移动语义
1.左值，左值引用，右值，右值引用
// 以下的p、b、c、*p都是左值
// 左值：可以取地址
int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("111111");
s[0];
cout << &c << endl;
cout << &s[0] << endl;
// 左值引用给左值取别名
int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
// 右值：不能取地址
double x = 1.1, y = 2.2;
// 以下几个都是常见的右值，常量临时对象，匿名对象
10;
x + y;
fmin(x, y);
string("11111");
//cout << &10 << endl;
// 右值引用给右值取别名
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x,y);
string&& rr4 = string("11111");
///
//左值引用引用给右值取别名：不能直接引用，但是const 左值引用可以
const int& rx1 = 10;
const double& rx2 = x + y;
const double& rx3 = fmin(x, y);
const string& rx4 = string("11111");
//适用场景
// void push(const T& x);
vector<string> v;
string s1("1111");
v.push_back(s1);
v.push_back(string("1111"));
v.push_back("1111");
//右值引用引用给左值取别名：不能直接引用，但是move(左值)以后右值引用可以引用
int&& rrx1 = move(b);
int*&& rrx2 = move(p);
int&& rrx3 = move(*p);
string&& rrx4 = move(s);
这里实际在底层看来是没有左右值区分的，都是用指针来实现的，move的本质也就相当于强制类型转换
2.右值引用使用场景和意义
引用的意义为减少拷贝，在这里左值引用解决的场景：引用传参/引用传返回值
但当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，
只能传值返回，这里就会有多次拷贝
因此提出使用右值引用的移动构造/赋值(移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己)来解决上述问题
但现在的编译器会做很大的优化处理，会影响观察到的结果，接下来就用一个实例来观察的
举例如下
cpp
namespace mjw
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
typedef const char* const_iterator;
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// s1.swap(s2)
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
// 拷贝构造
// s2(s1)
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 深拷贝" << endl;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 深拷贝" << endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
//string operator+=(char ch)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0; // 不包含最后做标识的\0
};
mjw::string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
mjw::string str;
while (value > 0)
{
int x = value % 10;
value /= 10;
str += ('0' + x);
}
if (flag == false)
{
str += '-';
}
std::reverse(str.begin(), str.end());
return str;
}
}
int main()
{
mjw::string s1;
s1 = mjw::to_string(1234);
return 0;
}
string的移动构造和移动赋值
cpp
// 移动构造
// 临时创建的对象，不能取地址，用完就要消亡
// 深拷贝的类，移动构造才有意义
string(string&& s)
{
cout << "string(string&& s) -- 移动拷贝" << endl;
swap(s);
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动拷贝" << endl;
swap(s);
return *this;
}在vs2022
这种编译器的最新优化下，上述过程还会优化的更深入，直接优化为构造
这里会想如果在这样优化的环境下，是不是移动构造/赋值就会意义，其实不然，就像下面的场景下是无法直接优化为构造的
对于右值引用的移动语义还有一些应用场景
对于大对象的传值返回，拷贝代价极大，就比如这里的杨辉三角
对于一些容器的插入接口也增加了右值引用的版本
3.关于右值引用本身的属性是左值的探究
问题引入：
在引入前面所写list文件(可从前面博客中寻找)后，在list.h中实现移动构造和移动赋值后
会发现这里的打印仍然是拷贝构造，移动构造并没有触发，造成这样的原因是
这里的右值引用x本身的属性还是左值，因此接下来还是会匹配到拷贝构造的
那么这里为啥要这样规定呢，其实主要是为了解决这个问题
如果这里swap(s),s的属性是右值的话，与swap函数的参数类型是不能匹配的，况且swap函数的参数类型只能写string&,const string&和string&& 的对象是不能修改的
因此为了解决上述问题可以使用move来解决的
4.完美转发
cpp
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
// 模版实例化是右值引用，右值引用属性会退化成左值，转换成右值属性再传参给Fun
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;
}对于这里的万能引用中Fun传参，是不能区分左右值的，都会被统一处理为左值，为了解决这个问题就可以使用完美转发
这时就会保持它的原有属性，不会发生右值退化为左值的情况
四：新的类功能
1.移动构造和移动赋值
cpp
class Person
{
public:
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
//~Person() {}
private:
mjw::string _name;
int _age;
};
int main()
{
Person s1;
Person s2 = s1;
Person s3 = std::move(s1);
Person s4;
s4 = std::move(s2);
return 0;
}如果这里没有显示写析构，拷贝构造，赋值的话，编译器就会自动生成移动构造和移动赋值
如果实现了其中的任意一个的话，就不会自动生成
2.强制生成默认函数的关键字default和禁止生成默认函数的关键字delete
在c++98中，当不想成员函数被拷贝时，就可以将成员函数只声明，不定义，放到private中；在c++11之后就采用delete关键字来解决
五：可变参数模板
cpp
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
//参数包包含多个类型和参数
template <class ...Args>
void ShowList(Args... args)
{}1.对函数形参参数包sizeof得参数包的参数个数
2.使用递归函数方式展开参数包
在这里如果要展开参数包的话，或许我们会首先想到这样的方法
但这样是不支持的，因为可变参数模板是在编译时解析的，而这样的方式是在运行时获取和解析的，所以不支持
这里就要使用在编译时递归推导解析参数
cpp
void Print()
{
cout << endl;
}
template <class T, class ...Args>
void Print(T&& x, Args&&... args)
{
cout << x << " ";
Print(args...);
}
// 编译时递归推导解析参数
template <class ...Args>
void ShowList(Args&&... args)
{
Print(args...);
}
int main()
{
ShowList();
ShowList(1);
ShowList(1, "xxxxx");
ShowList(1, "xxxxx", 2.2);
return 0;
}
对于这里的原理就是，比如是有三个参数的情况下，是将有三个参数的参数包传给args,再在编译时将参数包传给Print函数,就将第一个参数传给x然后解析出来，再将其余两个参数的参数包传给Print函数的第二个参数，再递归调用自己，依次解析参数包中的内容，直至为空，此时就调用Print()函数，完成整个参数包的解析
这里在编译器实例化的时候，其实是实例化为不同的函数，然后再分别调用，如下
3.使用逗号表达式展开参数包
cpp
template <class T>
void PrintArg(T t)
{
cout << t << " ";
}
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (PrintArg(args),0)... };
cout << endl;
}
// 编译推演生成下面的函数
//void ShowList(int x, char y, std::string z)
//{
// int arr[] = { PrintArg(x),PrintArg(y),PrintArg(z) };
// cout << endl;
//}
int main()
{
//ShowList(1);
//ShowList(1, 'A');
ShowList(1, 'A', std::string("sort"));
return 0;
}expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行
printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性------初始化列
表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)...}将会展开成((printarg(arg1),0),
(printarg(arg2),0), (printarg(arg3),0), etc... )，最终会创建一个元素值都为0的数组int arr[sizeof...
(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)
打印出参数，也就是说在构造int数组的过程中就将参数包展开了
也可以使用这样的方式
cpp
template <class ...Args>
void ShowList(Args... args)
{
int arr[] = { (cout<<(args)<<" ", 0)...};
cout << endl;
}
//void ShowList(int x, char y, std::string z)
//{
// int arr[] = { (cout<<(x)<<" ", 0), (cout << (y) << " ", 0), (cout << (z) << " ", 0) };
//
// cout << endl;
//}
int main()
{
ShowList(1, 'A', std::string("sort"));
return 0;
}4.emplace_back接口与push_back等插入接口的区别
cpp
.template <class... Args>
void emplace_back (Args&&... args); 这里对于普通的左值还是右值的插入，这两个区别不大
这里的可变参数模板是针对多参数的，与push_back()不同的地方为
往下传的过程中，就会直接构造对象进行插入操作，而push_back是先构造，再拷贝/移动构造
5.在list中模拟实现emplace_back版本
六：lambda表达式
1.实例引入
cpp
#include<algorithm>
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
//...
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct Compare1
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct Compare2
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), Compare1());
sort(v.begin(), v.end(), Compare2());
return 0;
}在实际的排序实例当中，一般都是对结构体按照某个成员为标准的排序，但这样的话，就需要写很多的仿函数来参与不同的排序，但当仿函数
的函数名是不明确的时候，这时还得查看源代码，于是为了清晰明了，减少仿函数，就引入了lambda表达式
- lambda表达式语法
3.简单的lambda表达式
实现加法
打印多行内容
lambda表达式的一些省略
4.关于捕获列表
实现一个交换函数
此时在函数体内部是无法直接使用a,b的，而要使用的话，就要使用捕捉列表的
要想改变外面捕捉的值，就得使用引用捕捉
其余几种捕捉方式
cpp
int x = 0;
int main()
{
// 只能用当前lambda局部域和捕捉的对象和全局对象
int a = 0, b = 1, c = 2, d = 3;
// 所有值传值捕捉
auto func1 = [=]
{
int ret = a + b + c + d + x;
return ret;
};
// 所有值传引用捕捉
auto func2 = [&]
{
a++;
b++;
c++;
d++;
int ret = a + b + c + d;
return ret;
};
// 混合捕捉
auto func3 = [&a, b]
{
a++;
// b++;
int ret = a + b;
return ret;
};
// 混合捕捉
// 所有值以引用方式捕捉，d用传值捕捉
auto func4 = [&, d]
{
a++;
b++;
c++;
//d++;
int ret = a + b + c + d;
};
auto func5 = [=, &d]() mutable
{
a++;
b++;
c++;
d++;
int ret = a + b + c + d;
};
return 0;
}对于最初的排序问题，就可以使用lambda表达式添加排序方案
cpp
// 价格升序
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
{
return g1._price < g2._price;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
{
return g1._price > g2._price;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
{
return g1._evaluate < g2._evaluate;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool
{
return g1._evaluate > g2._evaluate;
}); 5.函数对象与lambda表达式 ->探究lambda的底层实现
cpp
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.015;
Rate r1(rate);
cout << r1(10000, 2) << endl;
// lambda
auto r2 = [rate](double monty, int year)->double
{
return monty * rate * year;
};
cout << r2(10000, 2) << endl;
int x = 1, y = 2;
auto r3 = [=](double monty, int year)->double
{
return monty * rate * year;
};
cout << r3(10000, 2) << endl;
return 0;
}从使用方式上来看，函数对象与lambda表达式完全一样,函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到
运行代码转到底层汇编代码得
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如
果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
对于我们上层看到的是lambda表达式是一个匿名函数对象，但实际在底层是有函数名的，构成为lambda_uuid
七：包装器
1.function包装器
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器
1.function包装器的意义
ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下
因此提出了用包装器来解决问题，提供一种统一的方式来访问
std::function在头文件<functional>
模板参数说明：
Ret: 被调用函数的返回类型
Args...：被调用函数的形参
2.包装实例1
cpp
#include<functional>
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;
function<int(int, int)> f2 = Functor();
function<int(int, int)> f3 = [](int a, int b) {return a + b; };
cout << f1(1, 1) << endl;
cout << f2(1, 1) << endl;
cout << f3(1, 1) << endl;
// 包装静态成员函数
function<int(int, int)> f4 = &Plus::plusi;
cout << f4(1, 1) << endl;
// 包装非静态成员函数(注意有隐含的this指针)：方式1
function<double(Plus*, double, double)> f5 = &Plus::plusd;
Plus pd;
cout << f5(&pd, 1.1, 1.1) << endl;
//方式2
function<double(Plus, double, double)> f6 = &Plus::plusd;
cout << f6(pd, 1.1, 1.1) << endl;
cout << f6(Plus(), 1.1, 1.1) << endl;
return 0;
}实例2
2.bind包装器
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可
调用对象（callable object），生成一个新的可调用对象来"适应"原对象的参数列表。使用std::bind函数还可以实现参数顺序调整等操作
1.函数原型
2.实例演示
cpp
#include<functional>
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{
return (a - b) * 10;
}
int SubX(int a, int b, int c)
{
return (a - b - c) * 10;
}
int main()
{
// bind 本质返回的一个仿函数对象
// _1代表第一个实参
// _2代表第二个实参
// ...
auto sub1 = bind(Sub, _1, _2);
cout << sub1(10, 5) << endl;
// 调整参数顺序（不常用）
auto sub2 = bind(Sub, _2, _1);
cout << sub2(10, 5) << endl;
// 调整参数个数 （常用）
auto sub3 = bind(Sub, 100, _1);
cout << sub3(5) << endl;
auto sub4 = bind(Sub, _1, 100);
cout << sub4(5) << endl;
// 分别绑死第123个参数
auto sub5 = bind(SubX, 100, _1, _2);
cout << sub5(5, 1) << endl;
auto sub6 = bind(SubX, _1, 100, _2);
cout << sub6(5, 1) << endl;
auto sub7 = bind(SubX, _1, _2, 100);
cout << sub7(5, 1) << endl;
return 0;
}图示分析：
这里的bind包装器主要解决的是下面的这个例子
cpp
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<double(Plus, double, double)> f6 = &Plus::plusd;
Plus pd;
cout << f6(pd, 1.1, 1.1) << endl;
cout << f6(Plus(), 1.1, 1.1) << endl;
// bind一般用于，绑死一些固定参数
function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);
cout << f7(1.1, 1.1) << endl;
return 0;
}其余实例：
cpp
//auto func1 = [](double rate, double monty, int year)->double {return monty * rate * year;};
auto func1 = [](double rate, double monty, int year)->double {
double ret = monty;
for (int i = 0; i < year; i++)
{
ret += ret * rate;
}
return ret - monty;
};
function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);
function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);
function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);
function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);
cout << func3_1_5(1000000) << endl;
cout << func5_1_5(1000000) << endl;
cout << func10_2_5(1000000) << endl;
cout << func20_3_5(1000000) << endl;