目录
接下来的日子会顺顺利利,万事胜意,生活明朗-----------林辞忧
一:使用列表初始化
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.右值引用使用场景和意义
引用的意义为减少拷贝,在这里左值引用解决的场景:引用传参/引用传返回值
但当函数返回对象是一个局部变量,出了函数作用域就不存在了,就不能使用左值引用返回,
只能传值返回,这里就会有多次拷贝
因此提出使用右值引用的移动构造/赋值(移动构造本质是将参数右值的资源窃取过来,占位已有,那么就不用做深拷贝了,所以它叫做移动构造,就是窃取别人的资源来构造自己)来解决上述问题
但现在的编译器会做很大的优化处理,会影响观察到的结果,接下来就用一个实例来观察的
举例如下
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的移动构造和移动赋值
// 移动构造
// 临时创建的对象,不能取地址,用完就要消亡
// 深拷贝的类,移动构造才有意义
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.完美转发
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.移动构造和移动赋值
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关键字来解决
五:可变参数模板
// Args是一个模板参数包,args是一个函数形参参数包
// 声明一个参数包Args...args,这个参数包中可以包含0到任意个模板参数。
//参数包包含多个类型和参数
template <class ...Args>
void ShowList(Args... args)
{}
1.对函数形参参数包sizeof得参数包的参数个数
2.使用递归函数方式展开参数包
在这里如果要展开参数包的话,或许我们会首先想到这样的方法
但这样是不支持的,因为可变参数模板是在编译时解析的,而这样的方式是在运行时获取和解析的,所以不支持
这里就要使用在编译时递归推导解析参数
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.使用逗号表达式展开参数包
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数组的过程中就将参数包展开了
也可以使用这样的方式
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等插入接口的区别
.template <class... Args>
void emplace_back (Args&&... args);
这里对于普通的左值还是右值的插入,这两个区别不大
这里的可变参数模板是针对多参数的,与push_back()不同的地方为
往下传的过程中,就会直接构造对象进行插入操作,而push_back是先构造,再拷贝/移动构造
5.在list中模拟实现emplace_back版本
六:lambda表达式
1.实例引入
#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表达式
2. lambda表达式语法
3.简单的lambda表达式
实现加法
打印多行内容
lambda表达式的一些省略
4.关于捕获列表
实现一个交换函数
此时在函数体内部是无法直接使用a,b的,而要使用的话,就要使用捕捉列表的
要想改变外面捕捉的值,就得使用引用捕捉
其余几种捕捉方式
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表达式添加排序方案
// 价格升序
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的底层实现
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
#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.实例演示
#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包装器主要解决的是下面的这个例子
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;
}
其余实例:
//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;