C++11

目录

1.列表初始化

1.1 {}初始化

2.2 initializer_list

2.变量类型推导

2.1 auto

2.2 decltype

2.3 nullptr

3.范围for循环

4.final与override

5.右值引用和移动语义

5.1 左值和右值

5.2 左值引用和右值引用

5.3 右值引用退化

5.4 完美转发

6. 移动构造函数和移动赋值运算符重载

7. c++11类的其他新增功能

7.1 类成员变量初始化

7.2 强制生成默认函数的关键字 default

7.3 禁止生成默认函数的关键字 delete

8. 可变参数模板

9. STL容器中的emplace相关接口函数

10. lambda表达式

11. 包装器

11.1 function包装器

11.2 bind包装器(绑定)

1.列表初始化

1.1 {}初始化

struct A
{
int _a;
int _b;
};

void test1()
{
int arr[] = { 1,2,3,4,5 };
A a = { 1,2 };
}

//统一的列表初始化
struct stu
{
void print()
{
cout << _x << ' ' << _y << endl;
}
int _x;
int _y;
};
class A
{
public:
void print()
{
cout << _x << ' ' << _y << ' ' << _name << endl;
_u.print();
}
//要在public权限下才能使用{}直接初始化
int _x;
int _y;
string _name;
stu _u;
};
class B
{
public:
B(int x, int y = 3)
:_x(x), _y(y)//这是初始化列表，和列表初始化是两种东西
{}
void print()
{
cout << _x << ' ' << _y << endl;
}
private:
int _x;
int _y;
};
void test1()
{
//对结构体使用{}初始化
stu st = { 22,33 };
//可以不加=
stu st1{ 11,22 };
st.print();
//对类使用{}初始化
A a = { 22,22, "zhangsan", {44,55} };
A b { 23,24, "lisi", {42,55} };
a.print();
//对数组使用{}初始化
int array1[] = {1,2,3};
int array2[]{ 4,5,6 };
//对内置类型使用{}初始化
int i1 = { 100 };
double d1{ 99.999 };
int* p1{ nullptr };
//在new表达式中使用{}初始化
int* pa = new int[4] {1, 2, 3, 44};
for (int i = 0; i < 4; i++)
cout << *(pa + i) << ' ';
cout << endl;
//创建对象使用{}会调用构造函数初始化
B b1 = { 10 };
B b2{ 2,2 };//底层走的还是单参数和多参数的隐式类型转换
b1.print();
b2.print();
}

2.2 initializer_list

initializer_list 是 C++11 引入的一个特性，用于支持使用花括号 {} 语法进行初始化。它通常用于构造函数、操作符重载作为参数提供初始化的数据，简化了一些容器类的初始化。

//用于容器初始化--initializer_list
void test2()
{
auto il = { 1,2,3,4 };
cout << typeid(il).name() << endl;
//initializer_list作为构造函数的参数
vector<int> v1 = { 2,3,4,5,6,7 };
//外部的{}是initializer_list，内部的{}是隐式类型转换
list<C> l1 = { {1,2},{2,3},{3,4} };
//initializer_list作为operator=的参数
v1 = { 4,5,6,7 };
}

//模拟实现vector使用initializer_list初始化
namespace myvector
{
template <class T>
class vector
{
public:
typedef T* iterator;
vector(initializer_list<T> l)
{
_start = new T[l.size()];
_finish = _start + l.size();
_endofstorage = _start + l.size();

iterator vit = _start;
typename initializer_list<T>::iterator lit = l.begin();
while (lit != l.end())
*vit++ = *lit++;
//for (auto e : l)
//*vit++ = e;
}
vector<T>& operator=(initializer_list<T> l)
{
//调用上面使用initialize_list的构造函数，再交换资源，临时变量出作用域会自动析构
vector<T> tmp(l);
swap(tmp._start, _start);
swap(tmp._finish, _finish);
swap(tmp._endofstorage, _endofstorage);

return *this;
}
private:
iterator _start;
iterator _finish;
iterator _endofstorage;
};
}

2.变量类型推导

2.1 auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型。C++11中废弃auto原来的用法，将其用于实现自动类型推导。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

//auto自动类型推导
void test4()
{
auto i = 10;
map<string, string> mp = { {"1","1"} };

auto it = mp.begin();
map<string, string>::iterator it1 = mp.begin();

auto p1 = &i;
//加了 * 表示 p2 一定是指针类型
auto* p2 = &i;

cout << typeid(i).name() << endl;
cout << typeid(p1).name() << endl;
cout << typeid(p2).name() << endl;
cout << typeid(it).name() << endl;
cout << typeid(it1).name() << endl;
}

2.2 decltype

关键字decltype将变量的类型声明为表达式指定的类型。换句话说就是，decltype可以声明一个变量的类型，这个类型是表达式指定的类型。

//decltype
//关键字decltype将变量的类型声明为表达式指定的类型。
void test5()
{
//decltype可以声明一个变量的类型，这个类型是表达式指定的类型
int a = 1;
double b = 1.1111;
string  s = "asdfasddf";
string* p = &s;

decltype(&a) pa = &a;
decltype(a * b) d = a * b;
// ** 
decltype(&p) pp = &p;

cout << typeid(pa).name() << endl;
cout << typeid(d).name() << endl;
cout << typeid(pp).name() << endl;
}

2.3 nullptr

由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示
整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

void func(int x)
{
cout << "func(int x)" << endl;
}
void func(int* x)
{
cout << "func(int* x)" << endl;
}

//nullptr
void test6()
{
func(NULL);              //"func(int x)"
func((int*)NULL);      // "func(int* x)"
func(nullptr);             // "func(int* x)"
//C语言中，void*可以直接隐式类型转换其他指针类型的
//C++中，void *不能直接隐式类型转换，需要强转，nullptr可以转换成任意类型的指针
void* p1 = 0;
//int* p2 = p1;
int* p2 = (int*)p1;
}

void func(int* p)
{
cout << "func(int* p)" << endl;
}

void func(int p)
{
cout << "func(int p)" << endl;
}

void test1()
{
//C语言中，void*可以直接隐式类型转换其他指针类型的
//C++中，void *不能直接隐式类型转换，需要强转，nullptr可以转换成任意类型的指针
void* p = NULL;
//func(p);    //error
func((int*)p);   //int* p
func(nullptr);   //int* p
}

3.范围for循环

C++的范围for循环是C++11引入的一种便捷的循环结构，旨在简化遍历容器（如数组、vector、list等）中的元素。
基础语法：

for (declaration : collection) 
{  
    // 使用元素  
} 

底层实现：

范围for循环在底层实际上是通过调用特定的迭代器或协议来实现的。标准库容器通常会实现两个方法：

1. begin() - 返回指向容器第一个元素的迭代器。
2. end() - 返回指向容器尾后（超出最后一个元素）的迭代器。

范围for循环的工作原理基本上是这样的：

• 在循环开始时，调用 begin() 获取容器的起始迭代器。
• 在循环结束时，调用 end() 获取结束迭代器。
• 在每次迭代时，使用迭代器访问下一元素。

简单概括底层实现的伪代码：

auto begin = vec.begin();  
auto end = vec.end();  
for (auto it = begin; it != end; ++it) 
{  
    auto& x = *it; // 获取当前元素的引用  
    // 使用 x  
}

void test2()
{
vector<int> v = { 0,1,2,3,4 };
for (auto& e : v)         //通过引用可以改变元素
e += 1;
for (const auto& e : v)   //通过const引用，减少拷贝，避免修改元素
cout << e << ' ';
cout << endl;
}

4.final与override

在多态部分已经介绍过了

c++多态-CSDN博客

5.右值引用和移动语义

5.1 左值和右值

左值：左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址，也可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

右值：右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。

无论左值引用还是右值引用，都是给对象取别名。

void test3()
{
//左值
int a = 1;
const double b = 1.11;
int* pa = &a;
const double* pb = &b;
//左值引用
int& ra = a;
const double& rb = b;
int*& rpa = pa;
const double*& rpb = pb;
//右值
a + b;
10;
fmin(2,1);
//右值引用
double&& x = a + b;
int&& y = 10;
y = 1;
auto&& z = fmin(2, 1);
cout << &y << endl;
const int&& v = 10;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是y引用后，可以对y取地址，也可以修改y。如果不想y被修改，可以用const int&& y 去引用。
 

5.2 左值引用和右值引用

1.左值引用：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。

2.右值引用：

1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。

void test3()
{
//左值引用
int a = 143;
int& ra = a;
//int& r1 = 1;//error
const int& r1 = 1;
//右值引用
double b = 11111.1111;
double&& r2 = 1.1111;
//double&& rb = b;//error
double&& rb = move(b);
}

3.左值引用使用场景：做参数和返回值时可以减少拷贝，提高效率；
左值引用的短板：但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回，这时可能会用局部变量拷贝构造一个临时对象，再通过临时对象拷贝给外部接收的对象（编译器可能会优化成一次拷贝）

通过局部对象拷贝构造一个临时对象，返回的这个临时对象是一个右值，再通过这个右值去构造外部的对象，如果没有移动构造，调用就会匹配拷贝构造函数，因为const左值引用可以引用右值，所以整个过程进行了两次拷贝构造，但临时变量用完即销毁，所以可以通过右值引用将临时变量的资源与构造的对象进行交换，可以减少资源拷贝的开销。

4.右值引用和移动语义解决上述问题：
在bit::string中增加移动构造，移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。

在调用移动构造时，并没有新开空间和拷贝数据，提高了效率。

5.移动赋值：通过右值引用交换资源完成赋值操作

// 移动赋值
string& operator=(string&& s)
{
    cout << "string& operator=(string&& s) -- 移动语义" << endl;
    swap(s);
    return *this;
}
int main()
{
    bit::string ret1;
    ret1 = bit::to_string(1234);
    return 0;
}

6.左值引用和右值引用的底层
左值引用：语法上不开空间，底层会开空间--指针
右值引用：语法上不开空间，底层会开空间--指针

在汇编层面来说：没有左值引用和右值引用这些概念，底层都是指针

 7.右值引用给左值取别名--不能直接引用，但是move(左值)以后右值引用可以引用

string&& rrx5 = s; 这样写不能通过语法检查，因为类型不同，但通过对底层的了解，左值引用和右值引用底层都是指针，从底层的角度上面的写法是正确的，但语法层进行了限制：不能直接右值引用左值，(string&&)s实际上就是强转一下类型通过语法层。
move是类似类型转换，它的返回值是右值，不会改变原来的属性（move(左值)，里面仍是左值）

8.虽然说右值不能取地址，但右值本质上还是有地址和空间的，语法限制了取地址，所以右值引用底层才能取到地址（有时候语法层和底层是背离的）

5.3 右值引用退化

上述代码的本意是：传给f函数左值去调用左值作为参数的func，传给f函数右值去调用右值作为参数的func，但实际上右值传给f函数时，就发生了退化，变成了左值，所以结果都是调用左值作为参数的func函数。
解决方案：

1. move(退化的x)
2. 使用forward，在传参过程中保留对象原生类型属性

5.4 完美转发

万能引用：模板中的&&
std::forward 完美转发在传参的过程中保留对象原生类型属性

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用下面的完美转发。

void func(int& x)
{
cout << "func(int& x)" << endl;
}
void func(const int& x)
{
cout << "func(const int& x)" << endl;
}
void func(int&& x)
{
cout << "func(int&& x)" << endl;
}
void func(const int&& x)
{
cout << "func(const int&& x)" << endl;
}

template<class T>
void f(T&& t)
{
func(forward<T>(t));
}

int main()
{
int a = 1;
const int b = 2;
f(a);
f(b);
f(move(a));
f(move(b));
//结果
//func(int& x)
//func(const int& x)
//func(int&& x)
//func(const int&& x)

return 0;
}

6. 移动构造函数和移动赋值运算符重载

原来C++类中，有6个默认成员函数：

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值重载
5. 取地址重载
6. const 取地址重载

C++11 新增了两个：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

• 如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
• 如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
• 如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

7. c++11类的其他新增功能

7.1 类成员变量初始化

C++11允许在类定义时给成员变量初始缺省值

7.2 强制生成默认函数的关键字 default

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。

class Person
{
public:
Person(const char* name = "", int age = 0)
:_name(name)
, _age(age)
{}
Person(const Person& p)
:_name(p._name)
, _age(p._age)
{}
Person(Person&& p) = default;
private:
mystring::string _name;
int _age;
};

7.3 禁止生成默认函数的关键字 delete

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

class A
{
public:
//c++11 做法
A() = delete;
void print()
{
cout << _a << ' ' << _b << endl;
}
private:
//c++98 做法
//只声明且在private
A();
int _a = 1;
double _b = 0.1;
};

8. 可变参数模板

C++11的新特性可变参数模板能够创建可以接受可变参数的函数模板和类模板

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

带有省略号的参数称为"参数包"，里面包含了0到N个模板参数
参数包的名称不一定是args，可以自定义，参数包的标识是省略号
参数包中的每个参数无法通过args[ i ]的方式获取，只能通过展开参数包的方式来获取参数包中的每个参数，常用的展开参数包的方式有：递归函数方式展开参数包 和 逗号表达式展开。

递归函数方式展开参数包

递归展开参数包的方式如下：

• 给函数模板增加一个模板参数，这样就可以从接收到的参数包中分离出一个参数出来。
• 在函数模板中递归调用该函数模板，调用时传入剩下的参数包。
• 如此递归下去，每次分离出参数包中的一个参数，直到参数包中的所有参数都被取出来。

//递归终止函数
template <class T>
void ShowList(const T& t)
{
//参数包剩一个参数时
cout << t << endl;
}
//展开函数
template <class T, class ... Args>
void ShowList(const T& value, Args ... args)
{
cout << value << ' ';
ShowList(args...);
}

int main()
{
int a = 1000;
ShowList(std::string("string_string"), 1, 11.111, "str",a);

return 0;
}

逗号表达式展开

使用逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分print(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。

template<class T>
void print(const T& t)
{
cout << t << ' ';
}
//没传入参数
void ShowList()
{}
//展开函数
template <class ... Args>
void ShowList(Args ... args)
{
int arr[] = { (print(args),0)... };

cout << endl;
}

int main()
{
ShowList(1, 2, 2, 3,"string");
ShowList();

return 0;
}

还可以这样写：

template<class T>
int print(const T& t)
{
cout << t << ' ';
return 0;
}
//没传入参数
void ShowList()
{}
//展开函数
template <class ... Args>
void ShowList(Args ... args)
{
int arr[] = { print(args)... };

cout << endl;
}

int main()
{
ShowList(1, 2, 2, 3,"string");
ShowList();

return 0;
}

获取参数包个数

template<class ...Args>
void ShowList(Args... args)
{
cout << sizeof...(args) << endl; //获取参数包中参数的个数
}

9. STL容器中的emplace相关接口函数

C++11标准给STL中的容器增加emplace版本的插入接口，比如list容器的push_front、push_back和insert函数，都增加了对应的emplace_front、emplace_back和emplace函数。

emplace相关的接口支持可变模板参数，&&表示万能引用，不是右值引用。

emplace相关接口与容器原有的插入接口的使用方式类型，但还是存在不同之处：
以list容器的emplace_back和push_back为例：

• 调用push_back函数插入元素时，可以传入左值对象或者右值对象，也可以使用列表进行初始化。
• 调用emplace_back函数插入元素时，也可以传入左值对象或者右值对象，但不可以使用列表进行初始化。
• emplace系列接口最大的特点就是，插入元素时可以传入用于构造元素的参数包。

具体使用：

void test2()
{
list<pair<string, int>> li;
pair<string, int> point("why", 10);
//传左值
li.emplace_back(point);
//传右值
li.emplace_back(pair<string, int>("what", 11));
//传参数包
li.emplace_back("who", 12);

//传左值
li.push_back(point);
//传右值
li.push_back(pair<string, int>("when", 13));
//列表初始化--匿名对象
li.push_back({ "where", 14 });
}

emplace相关接口工作流程：

1. 先通过空间配置器为新结点获取一块内存空间，注意这里只会开辟空间，不会自动调用构造函数对这块空间进行初始化。
2. 然后调用allocator_traits::construct函数对这块空间进行初始化，调用该函数时会传入这块空间的地址和用户传入的参数（需要经过完美转发）。
3. 在allocator_traits::construct函数中会使用定位new表达式，显示调用构造函数对这块空间进行初始化，调用构造函数时会传入用户传入的参数（需要经过完美转发）。
4. 将初始化好的新结点插入到对应的数据结构当中，比如list容器就是将新结点插入到底层的双链表中。

emplace系列接口的意义：

由于emplace系列接口的可变模板参数的类型都是万能引用，因此既可以接收左值对象，也可以接收右值对象，还可以接收参数包。

• 如果调用emplace系列接口时传入的是左值对象，那么首先需要先在此之前调用构造函数实例化出一个左值对象，最终在使用定位new表达式调用构造函数对空间进行初始化时，会匹配到拷贝构造函数。
• 如果调用emplace系列接口时传入的是右值对象，那么就需要在此之前调用构造函数实例化出一个右值对象，最终在使用定位new表达式调用构造函数对空间进行初始化时，就会匹配到移动构造函数。
• 如果调用emplace系列接口时传入的是参数包，那就可以直接调用函数进行插入，并且最终在使用定位new表达式调用构造函数对空间进行初始化时，匹配到的是构造函数。

所以emplace接口的意义，是支持传入参数包，用这些参数包直接构造出对象，这样就能减少一次拷贝，提高效率；但传入左值对象或者右值对象时，emplace接口与其他插入接口效率一样。

10. lambda表达式

lambda表达式书写格式：[ capture-list ] ( parameters ) mutable -> return-type { statement }

•  [ capture-list ]：捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
• (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
• mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
• ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
• {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
   

注意：在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

void test1()
{
auto f = [](int a, int b) {return a + b; };
cout << f(2, 3) << endl;
}

捕获列表说明：
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

• [var]：表示值传递方式捕捉变量var
• [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
• [&var]：表示引用传递捕捉变量var
• [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
• [this]：表示值传递方式捕捉当前的this指针

注意：

• 父作用域指包含lambda函数的语句块
• 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
  比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
• 捕捉列表不允许变量重复传递，否则就会导致编译错误。比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
• 在块作用域以外的lambda函数捕捉列表必须为空。
• 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。
• lambda表达式之间不能相互赋值，即使看起来类型相同

lambda表达式与仿函数

在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象（仿函数）的方式处理的，即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。

class add
{
public:
int operator()(int a, int b)
{
return a + b;
}
};

void test2()
{
cout << [](int a, int b) {return a + b; }(1, 2) << endl;
cout << add()(1,2) << endl;
}

C++ 的 lambda 表达式本质上是函数对象。根据 C++ 标准，lambda 表达式会被编译为一个匿名的函数对象，这个对象重载了 operator（），允许通过调用它的实例来执行 lambda 表达式的内容。

虽然 lambda 表达式可以被转换为函数指针（例如对于没有捕获的 lambda 表达式，且可以用函数指针类型接收），但其主要特性是能够捕获上下文中的变量，这意味着它可以在其周围的作用域中访问变量。而函数指针则无法做到这一点。因此，lambda 的主要形式是函数对象，具备更大的灵活性和功能性。

11. 包装器

11.1 function包装器

function包装器，也叫作设配器，C++中function本质是一个类模板，也是一个包装器。
function用于包装可调用类型，例如：函数名，函数指针，函数对象（仿函数），lambda表达式等，使类型统一。

头文件：<functional>

类模板原型：

template <class T> function;     // undefined--未定义
template <class Ret, class... Args> class function<Ret(Args...)>;

function使用：
function<返回值类型（参数类型）> 名字 =  可调用类型

 使用场景：

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;
}

上面的useF会根据传入的F的类型不同，实例化多个useF函数。

用function<double(double)>类型来包装不同的调用类型，可以减少useF模板的实例化，提高效率。

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()
{
// 函数名
std::function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function<double(double)> func3 = [](double d)->double { return d / 4; };
cout << useF(func3, 11.11) << endl;
return 0;
}

包装普通成员函数有几个问题：
1.普通成员函数取地址需要加&，静态成员函数和普通函数可加可不加
2.普通成员函数参数列表隐含this指针

解决方案：
1.包装添加指针类型（传地址需要先构造对象再取地址)

2.包装添加类类型（直接传对象或匿名对象）

底层：function中将保存普通成员函数的指针，使用function包装的普通成员函数，并非是将function类型的对象的参数直接传给普通成员函数做参数（例如：this指针不支持显示传递)，内部实现是通过function实现的operator()，operator()内部通过对象或者对象指针来调用普通成员函数，这也就解释了为什么可以使用1和2的解决方案

11.2 bind包装器(绑定)

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
 

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示
newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

_n占位符在placeholder的命名空间内
 

int sub(int a, int b)
{
return a - b;
}

class add
{
public:
int sub(int a, int b)
{
return a + b;
}
};

template <class T>
class print
{
public:
void operator()(const T& t)
{
cout << t << endl;
}
};

int main()
{
using namespace placeholders;
//绑定函数sub，参数分别调用func1的第一，二个参数指定
function<int(int, int)> func1 = bind(sub, _1, _2);
//参数调换顺序
function<int(int, int)> func2 = bind(sub, _2, _1);
cout << func1(10, 1) << endl;   // 9
cout << func2(10, 1) << endl;   // -9

//绑定成员函数
function<int(int, int)> func3 = bind(&add::sub, add(), _1, _2);
cout << func3(7,6) << endl;

//参数绑死
auto func4 = bind(sub, 100, _1);
cout << func4(10) << endl;
cout << func4(99) << endl;

//绑定仿函数
auto func5 = bind(print<string>(), _1);//需要显示实例化，不能自动推导
func5("hello world");

//绑定lambda
auto func6 = bind([](int a, int b) {return a + b; }, _1, _2);
cout << func6(20, 9) << endl;

auto func7 = bind(func5, _1);
func7("yes");

return 0;
}

总结：bind，function，lambda返回的都是一个仿函数对象

原文地址：https://blog.csdn.net/cookies_s_/article/details/142425990

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！