C++ - C++11
文章目录
- 1. std::initializer_list
- 2. decltype
- 3. 左值引用和右值引用
- 4. 完美转发(模板中的&&万能引用)
- 5. 类的新功能
- 6. 可变参数模板
- 7. lambda表达式
- 8. 包装器
1. std::initializer_list
- 内置类型
int main()
{
/* 内置类型 */
int x1 = 1;
int x2 = { 2 };
int x3{ 3 };
int y1 = 1;
int y2(2);
printf("x1:%d, x2:%d, x3:%d, y1:%d, y2:%d\n", x1, x2, x3, y1, y2);
//输出结果：x1:1, x2:2, x3:3, y1:1, y2:2
return 0;
}
- 自定义类型
struct Student
{
int _age;
string _name;
Student(const int& age, const char* name)
:_age(age)
, _name(name)
{
cout << "Student(const int& age, const char* name)" << endl;
}
};
int main()
{
Student s1(18, "张三");
Student s2{ 20, "李四" };
//输出结果：
//Student(const int& age, const char* name)
//Student(const int& age, const char* name)
return 0;
}
上述例子反汇编可以看出来{}初始化和()初始化一样调用的是构造函数
- 数组和vector{}初始化
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[]{ 1,2,3,4,5 };
vector<int> v1(arr1, arr1 + 5);
//简便初始化
vector<int> v2{ 1,2,3,4,5 };
return 0;
}
- arr1和arr2
- v1
- v2
- list{}初始化和map初始化
int main()
{
list<int> l1 = { 1,2,3,4,5 };
map<string, string> dict = { {"string", "字符串"}, {"sort", "排序"}, {"other", "其他的"} };
return 0;
}//同样都会调用initializer_list对象构造
- initializer_list
int main()
{
auto f = { 1,2,3,4,5 };
cout << typeid(f).name() << endl; //class std::initializer_list2. decltype
关键字decltype将变量的类型声明为表达式指定的类型
struct Object
{
string _property = "struct Object";
size_t _size = 1;
Object()
{}
};
int main()
{
Object ob1;
//要求：ob2必须和ob1一个类型
decltype(ob1) ob2;
cout << typeid(ob2).name() << endl;
return 0;
}
3. 左值引用和右值引用
什么是左值？什么是左值引用？什么是右值？什么是右值引用？
左值：数据表达式(变量名或者解引用的指针)，可以取地址的值是左值
左值引用：给左值取别名
右值：数据表达式(常量，临时变量，临时对象)，不可以取地址的值是右值
右值引用：给右值取别名
struct Object
{
static size_t _size;
Object()
{}
};
size_t Object::_size = 1;
int main()
{
// *p,b,c,o都是左值
int* p = new int[5];
int b = 1;
const int c = 1;
Object o;
cout << o._size << endl;
// rp,rb,rc,ro都是左值引用，这里左值引用给左值取别名
int*& rp = p;
int& rb = b;
const int& rc = c;
Object& ro = o;
int x = 1, y = 2; //左值
// 右值
1;
x + y;
// 右值引用
int&& rs = x + y; //右值引用给右值取别名
const int& r = x + y; //左值引用给右值取别名
//int&& rr = x; //（err）右值引用不能给左值取别名
int&& rr = move(x); //右值引用可以给move后的左值取别名
return 0;
}
const左值引用可以给右值取别名，那么右值引用有什么作用呢？ 看使用场景：
场景一：(作用：参数更匹配)
void test(int& x)
{
cout << "void test(int& x)" << endl;
}
void test(int&& x)
{
cout << "void test(int&& x)" << endl;
}
int main()
{
int a = 2, b = 4;
test(a);
test(a + b);
return 0;
}
场景二：（移动构造）
移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自身。
namespace MySTL
{
class string
{
public:
string(const char* str = "")
: _size(strlen(str))
, _capacity(_size)
{
cout << "string(const char* str = "") -- 构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
string tmp(s._str); //构造
swap(tmp); //将亡值tmp给到this掌管
}
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 拷贝赋值" << endl;
string tmp(s); //构造
swap(tmp);
return *this;
}
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;
}
~string()
{
delete[] _str;
_str = nullptr;
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
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)
{
push_back(ch);
return *this;
}
string operator+(const char ch)
{
string tmp(*this); //拷贝构造
tmp += ch;
return tmp;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
}
int main()
{
MySTL::string s("string"); //构造
MySTL::string ret1 = s; //拷贝构造
MySTL::string ret2 = (s + '?'); //移动构造
return 0;
}
编译器默认临时对象作为函数返回值调用移动构造，ret2和tmp只是发生浅拷贝交换指针，并没有发生深拷贝，而是资源转移，提高了性能。如果这里没有写移动构造，那么会进行拷贝构造发生深拷贝
注意：不要轻易move左值（会导致资源转移）
库中使用场景：
namespace MySTL
{
class string
{
public:
string(const char* str = "")
: _size(strlen(str))
, _capacity(_size)
{
cout << "string(const char* str = "") -- 普通构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
string tmp(s._str); //普通构造
swap(tmp);
}
string(string&& s) //移动构造的作用就是浅拷贝将亡值
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
~string()
{
delete[] _str;
_str = nullptr;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
}
int main()
{
std::list<MySTL::string> list;
MySTL::string s1("construct");
list.push_back(s1); //调用void push_back(const value_type& val)
list.push_back(MySTL::string("move construct")); //调用void push_back (value_type&& val);
list.push_back("move construct"); //调用void push_back (value_type&& val);
return 0;
}
//输出结果：
//string(const char* str = ) -- 普通构造
//string(const string& s) -- 拷贝构造
//string(const char* str = ) -- 普通构造
//string(const char* str = ) -- 普通构造
//string(string&& s) -- 移动构造
//string(const char* str = ) -- 普通构造
//string(string&& s) -- 移动构造
左值引用和右值引用优点：
都是提高效率，减少数据拷贝。左值引用一般用在函数参数和返回自身对象this，const左值引用会延长传参临时对象的生命周期，右值引用一般用在函数将亡对象返回。
4. 完美转发(模板中的&&万能引用)
#include 上面这里右值传递依然是左值引用，这是为什么呢？右值引用引用后的属性是左值。怎么来证明？
int main()
{
int&& x = 10;
cout << &x << endl; //能取地址的皆为左值，右值引用后会把对饮数据存放起来，x就是存放空间的标签，属性变为左值
return 0;
}
这里如何解决上述中PerfectForward函数通过模板调用预期对应的函数呢？完美转发方法
函数：
template T&& forward (typename remove_reference::type&& arg) noexcept;
template T&& forward (typename remove_reference::type& arg) noexcept;
作用：如果arg不是左值引用，则返回对arg的右值引用。如果arg是一个左值引用，则该函数返回arg而不修改其类型。
#include 完美转发使用场景：
#define _CRT_SECURE_NO_WARNINGS true
#include 5. 类的新功能
移动构造
如果没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
移动赋值
如果没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。
#define _CRT_SECURE_NO_WARNINGS true
#include 强制生成默认函数的关键字default
#define _CRT_SECURE_NO_WARNINGS true
#include 禁止生成默认函数的关键字delete
#define _CRT_SECURE_NO_WARNINGS true
#include 6. 可变参数模板
#include
using namespace std;
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{
cout << sizeof...(args) << " "; //打印函数形参参数包个数
}
int main()
{
ShowList();
ShowList('x', 'y');
ShowList('w', 1, 2);
ShowList("string", 1, 2, 3);
ShowList(3.14, std::vector<int>(5, 1), std::list<int>(5, 2));
return 0;
}
如何解析可变参数包？（递归方式展开包）
#include
using namespace std;
void ShowList()
{
cout << endl;
}
template <class T, class ...Args>
void ShowList(const T& value, Args... args)
{
cout << value << " ";
ShowList(args...);
}
int main()
{
ShowList(); //调用ShowList();
ShowList('x', 'y'); //调用ShowList(const T& value, Args... args)
ShowList('w', 1, 2);
ShowList("string", 1, 2, 3);
return 0;
}
画图理解参数包
逗号表达式展开参数包
#include 类似于下面这种形式:
void ShowList(int a, int b, char c, std::string s)
{
int arr[] = { PrintArg(a), PrintArg(b), PrintArg(c), PrintArg(s)};
cout << endl;
}
int main()
{
ShowList(1, 2,'A', std::string("string"));
return 0;
}
库中list:emplace_back使用场景
#include
using namespace std;
class Date
{
friend ostream& operator<<(ostream& cout, const Date& date);
private:
int _year;
int _month;
int _day;
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
{
cout << "Date(int year, int month, int day) - 普通构造函数" << endl;
}
};
ostream& operator<<(ostream& cout, const Date& date)
{
cout << date._year << "/" << date._month << "/" << date._day << endl;
return cout;
}
int main()
{
std::list<Date> list;
list.emplace_back(2023, 3, 4); //可变模板推导调用构造函数
std::list<Date>::const_iterator it = list.begin();
while (it != list.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
7. lambda表达式
#include 随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。
lambda表达式语法
书写格式：[capture-list] (parameters) mutable -> return-type { statement}
1.[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
2.(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
3.mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
4.->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
5.{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
测试用例
int main()
{
auto sum = [](int x, int y)->int {
return x + y;
};
cout << [](int x, int y)->int {return x + y; }(1, 2) << endl;
cout << sum(1, 2) << endl;
return 0;
}
//不使用operator()而是使用lambda表达式
#include 捕捉列表的关键
- [var]：表示值传递方式捕捉变量var
- [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
- [&var]：表示引用传递捕捉变量var
- [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
- [this]：表示值传递方式捕捉当前的this指针
- [&, var]、[var, &] : 混合捕捉
#include 捕捉列表注意事项
- 语法上捕捉列表可由多个捕捉项组成，并以逗号分割
- 捕捉列表不允许变量重复传递，否则就会导致编译错误
- 在块作用域以外的lambda函数捕捉列表必须为空
- lambda表达式之间不能相互赋值
lambda表达式原理
#include 对应的汇编代码：
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。
8. 包装器
template <class Ret, class... Args> class function<Ret(Args...)>;
Ret: 返回值类型, Args:可变参数类型
#include