现代C++学习

类和对象

类的基本知识

类的构造函数

构造函数的名字和类名相同，没有返回类型。对象创建时会自动调用，用来保证对象一出生就是“可用状态”。

常见形式：

默认构造函数（无参）
带参构造函数
委托构造函数（构造函数里调用同类其他构造函数，C++11）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Person {
private:
	std::string name;
	int age;

public:
	Person() : name("unknown"), age(0) {}
	Person(std::string n, int a) : name(std::move(n)), age(a) {}
	Person(std::string n) : Person(std::move(n), 18) {}
};

常见坑：

构造函数体内赋值不等于成员初始化，优先使用初始化列表。
成员初始化顺序由“声明顺序”决定，不是初始化列表书写顺序。

类的拷贝构造函数

拷贝构造就是“用一个同类型老对象，生成一个新对象”。

典型签名：

1

ClassName(const ClassName& other);

如果类里只有基础类型和标准库对象，编译器默认生成的拷贝构造通常就够用；如果类管理的是裸资源（如 new 出来的指针），就要自己实现深拷贝，不然容易出现二次释放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Buffer {
private:
	char* data;
	std::size_t size;

public:
	explicit Buffer(std::size_t n) : data(new char[n]), size(n) {}

	Buffer(const Buffer& other) : data(new char[other.size]), size(other.size) {
		std::memcpy(data, other.data, size);
	}

	~Buffer() {
		delete[] data;
	}
};

浅拷贝与深拷贝：

浅拷贝：只复制指针值，两个对象指向同一块内存。
深拷贝：复制资源本体，每个对象各管各的资源。

类的移动构造函数

移动构造不是“复制资源”，而是“接管资源”。

典型签名：

1

ClassName(ClassName&& other) noexcept;

当右值对象（临时对象，或被 std::move 转换后的对象）初始化新对象时，移动构造可以避免深拷贝，提高性能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Buffer {
private:
	char* data;
	std::size_t size;

public:
	explicit Buffer(std::size_t n) : data(new char[n]), size(n) {}

	Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {
		other.data = nullptr;
		other.size = 0;
	}

	~Buffer() {
		delete[] data;
	}
};

常见坑：

移动构造建议加 noexcept，容器（如 std::vector）扩容时才更愿意走移动路径。
被移动对象必须保持“可析构、可赋值”的有效但未指定状态。

类的析构函数

析构函数就是对象的“收尾清理”。

典型签名：

1

~ClassName();

析构函数会在对象生命周期结束时自动调用：

局部对象离开作用域。
delete 动态对象。
程序结束时销毁全局/静态存储期对象。

当类作为基类并且要“通过基类指针删除派生类对象”时，基类析构函数必须是虚函数。

1
2
3
4
5
6
7
8
9


class Base {
public:
	virtual ~Base() = default;
};

class Derived : public Base {
public:
	~Derived() override = default;
};

常见坑：资源管理类通常遵循“规则五（Rule of Five）”，即拷贝构造、拷贝赋值、移动构造、移动赋值、析构这五个函数要整体考虑。

类的继承与多态

多态实现的前提

类的成员函数有虚函数
公有继承的派生类
派生类对这个虚函数进行了重写
使用基类的指针或引用指向派生类对象还需要注意：如果用基类指针指向派生类对象，并通过这个基类指针 delete，那么基类析构函数必须是虚函数，否则只会调用基类析构，不会完整调用派生类析构。

纯虚函数（抽象类）

1
2
3
4


class Shape{
	public :
		virtual void draw()=0;
};

不可实例化，需要派生一个类且重写虚函数，实例化派生类

类的进阶知识

override和final限定符

override 和 final 是 C++11 引入的上下文关键字。

在派生类中重写虚函数时，使用 override 可以让编译器检查函数签名是否真的匹配基类，防止“看起来像重写，其实是重载”的错误。

final 可以阻止继续重写：

修饰虚函数：禁止更下层派生类再重写。
修饰类：禁止该类再被继承。

它们不是完全保留关键字，在普通上下文里仍可作为标识符使用，但实际开发中不建议这么写，避免降低可读性。

1
2
3
4
5
6
7
8
9


class Base {
public:
	virtual void run(int x) {}
};

class Child : public Base {
public:
	void run(int x) override {}
};

静态成员

静态成员属于类本身，不属于某个对象。

静态成员变量不依赖对象存在，通常用于：

统计同类对象数量。
维护类级共享配置。
单例模式中的实例入口（只是场景之一，不是唯一用途）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Demo {
public:
	static int count;
	static void increase() { ++count; }
};

int Demo::count = 0;

int main() {
	Demo demo;
	demo.increase();
	Demo::increase();
}

静态成员函数里没有 this 指针，所以不能直接访问非静态成员；但可以通过传入对象，再间接访问对象成员。

const成员函数

const 成员函数承诺“不会修改对象可观察状态”。

本质上可以理解为：this 的类型变成了 const ClassName*。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Demo {
private:
	int x = 0;
	mutable int queryCount = 0;

public:
	int calculate(int a, int b) const {
		++queryCount; // mutable 成员可在 const 函数中修改
		return a + b + x;
	}
};

const 对象只能调用 const 成员函数，不能调用非常量成员函数。

1
2


const Demo d;
// d.calculate(1, 2); // 可以

this指针

this 就是“当前对象自己的地址”。

在非静态成员函数中，编译器会隐式传入 this 指针。

普通成员函数中：this 类型近似 ClassName*。
const 成员函数中：this 类型近似 const ClassName*。

典型用法：

解决成员名和参数名冲突。
返回 *this 以支持链式调用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Counter {
private:
	int value = 0;

public:
	Counter& add(int value) {
		this->value += value;
		return *this;
	}
};

访问父类中的函数

在子类中调用父类版本函数，可以使用作用域解析运算符：

1

BaseClass::hello();

如果子类定义了同名函数，会隐藏父类的重载集合，可用 using 重新引入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class Base {
public:
	void hello() {}
	void hello(int x) {}
};

class Child : public Base {
public:
	using Base::hello;
	void hello(double x) {}
};

友元函数与类

友元是“被特批访问私有成员的外部函数/类”。

友元不属于类成员，但可以访问类的 private/protected。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Box {
private:
	int value;

public:
	explicit Box(int v) : value(v) {}
	friend int readValue(const Box& b);
};

int readValue(const Box& b) {
	return b.value;
}

注意点：

友元关系是单向的、不可继承的。
友元是“打洞”机制，能不用就少用，优先保持封装性。

模板

函数模板

基本概念

1
2


template<class T1, class T2, ...> 函数声明;
template<typename T1, typename T2, ...> 函数声明;

模板函数描述的是“生成函数的规则”，编译器在看到具体类型后进行实例化，才会生成真正的函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


template<class T>
void mySwap(T& a, T& b) {
	T temp = a ;
	a = b;
	b = temp;
}

int main() {
	int a = 1 , b = 3 ;
	mySwap<int>(a,b);
}

补充：class 和 typename 在模板参数列表中等价，二者都可以用。

显式实例化

显式实例化是“我提前告诉编译器：这个类型版本一定要生成”。

1

template float max<float>(float a, float b);

如果不显式实例化，通常由编译器根据调用点进行隐式实例化。

实例化与特化的区别

实例化（Instantiation）：按模板规则“生成代码”。
特化（Specialization）：为某些特定类型“单独写实现”。

特化(Specialization)

特化分为全特化和偏特化：

函数模板：只支持全特化，不支持偏特化（可用重载替代）。
类模板：支持全特化和偏特化。

1
2
3
4
5


template<> 
double max<double>(double a , double b) {
	std::cout << "Specialized Template Function Call" << std::endl ;
	return a>b?a:b;
}

类模板

基本概念

类模板就是“按类型生成类”的模具。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


template<typename T>
class Storage {
private:
	T value;

public:
	explicit Storage(T v) : value(v) {}
	T get() const { return value; }
};

int main() {
	Storage<int> a(10);
	Storage<std::string> b("hello");
}

如果类模板成员函数在类外定义，要重复模板声明：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


template<typename T>
class Holder {
public:
	void set(T v);
private:
	T value{};
};

template<typename T>
void Holder<T>::set(T v) {
	value = v;
}

类模板的特化

类模板全特化后，本质是一个全新的类定义，不会自动继承主模板实现。

此外类模板还支持偏特化（部分特化）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


template<typename T>
class Printer {
public:
	void print() { std::cout << "normal type" << std::endl; }
};

template<typename T>
class Printer<T*> {
public:
	void print() { std::cout << "pointer type" << std::endl; }
};

非类型模板参数

模板参数不一定是类型，也可以是常量值。

1
2
3
4
5
6
7
8


template<typename T, std::size_t N>
class FixedArray {
private:
	T data[N]{};

public:
	constexpr std::size_t size() const { return N; }
};

常见非类型模板参数：整数、枚举、指针、引用、std::nullptr_t（不同标准版本支持范围略有差异）。

模板嵌套

类模板的参数还可以是一个模板

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


template<template<typename> class Container, typename T>
class Wrapper {
private:
	Container<T> data;
};

template<typename T>
class MyVector {
private:
	std::vector<T> data;
};

补充说明：

这种写法常见于“策略类/容器适配器”。
模板是后面泛型 lambda、完美转发的基础能力，后面章节会用到这里的类型推导思想。

lambda表达式

一起来学C++ 32.Lambda表达式_哔哩哔哩_bilibili C++14以后引入了泛型lambda

定义方式

1
2
3


[捕获变量](参数列表) 可选限定符 -> 返回类型{
	//函数代码
}

若省略返回类型，编译器会自动推导

例子

1
2
3
4
5
6
7
8


int main(void) {
	int x = 1 ;
	float y = 2.0 ;
	auto p = [x,y](int a,int b) -> float {
		return x*y+a*b ;
	};
	cout << p(1,3) << endl ;
}

本质

lambda表达式的本质是函数对象的一种快捷定义方式，同时会有的捕获变量的成员变量

1
2
3
4
5


int x = 1;
float y = -1.0 ;
auto p = [x,y](int a , int b)->float{
	return x*y+a*b ;
}

本质形式如下

1
2
3
4
5
6
7


struct {
	int _x;
	float _y;
	float operator()(int a, int b) const {
		return _x*_y+a*b ;
	}
}p{x,y};

按值捕获&按引用捕获

捕获变量有两种方式，按值捕获和按引用捕获

按值捕获，初始化时只是复制了x,y的值

1
2
3


auto p = [x,y](int a,int b) -> float {
	return x*y+a*b ;
};

按引用捕获，匿名函数对象内部的成员变量会被初始化为变量x,y的引用

1
2
3


auto p = [&x,&y](int a,int b) -> float {
	return x*y+a*b ;
};

lambda函数所对应的函数调用运算符默认是const函数，也就是说函数内部不能修改按值捕获的成员变量，如果捕获的是对象，也不能调用这个对象的非常量函数，若是按引用捕获，则不会受此限制

如果给lambda函数加上mutable限制符，那么对应的调用函数就不再是const函数，捕获的成员都是可以修改的

在捕获字句中，还可以使用默认捕获

1
2


[=]//默认按值捕获
[&]//默认按引用捕获

下面的例子中，用到的外层变量x,y都会被捕获，并生成对应的拷贝成员

1
2
3
4
5
6
7
8


int main() {
	int x = 1 ;
	float y = 2.0f;
	float z = 1.2f ;
	auto p = [=](int a , int b )->float{
		return x*y+a*b;
	};
}

同样可以进行修改，使特定变量以显式形式被捕获

1
2
3


auto p = [=,&y](int a , int b )->float{
	return x*y+a*b;
};

需要注意的是，默认捕获与显式捕获不能是同类型的

1
2
3
4


//wrong
auto p = [&,&y](int a , int b )->float{
	return x*y+a*b;
};

还需要注意，使用引用捕获时，若调用lambda对象时，引用变量以及失效，则程序运行的时候会出现错误或者异常

如果在一个类中定义lambda对象时，可以用以下方式来捕获this指针或者*this解引用

1
2


[this]  //按引用捕获
[*this] //按值捕获，C++17以后

泛型lambda

在C++14标准以后，引入了泛型lambda,实现的方法是在函数的参数类型中使用auto关键字

1

auto f =[](auto x , auto y){return x+y;};

这样其本质就是如下所示，用以简化lambda的泛化方式

1
2
3
4


template<class T1 , class T2>
struct ClosureType{
	auto operator()( T1 x , T2 y ) {return x+y;};
};

右值引用与移动语义

左值与右值

左值能放在表达式的左侧，能够代表一块存储区域，判断左值的方式一般是能否获得这个表达式的引用或者取地址

计算中间结果等存放在临时中间对象中的是右值（纯右值）

1
2
3
4


//下面的表达式右侧都是右值
x = 2 ;
x = m+n ;
x = (double)z;

在C++11之后，有glvalue（泛左值）和prvalue（纯右值），泛左值有被分为lvalue（左值）和xvalue(eXpiring value)（亡值）

右值引用

使用&&来定义右值的引用，右值的引用只能绑定右值

1

int && a = 5 ;

有了右值引用就可以在函数调用时将左值参数和有值参数分开

基于此还会引申出移动构造函数和移动赋值运算符重载函数（右值引用的参数）这两个函数与拷贝构造函数和拷贝赋值运算符重载函数（左值引用的参数）类似

在实际代码中

1

CharBuffer buff{ CharBuffer(100) };

使用一个右值来初始化buff对象，应该会调用移动构造函数，但实际上调用的是普通构造函数（连拷贝构造函数也不是），其原因是拷贝省略（Copy Elison）的优化，直接省略临时对象的创建，并直接在目标的存储位置构造对象

在函数返回等场景也会有优化，都是省略临时对象的创建，例如返回值优化（Return Value Optimization(RVO)），具名返回值优化（Named Return Value Optimization(NRVO)）等

移动语义

1
2


CharBuffer buff1(99);
CharBuffer buff2 = buff1 ;

此时buff1调用的是普通构造函数，buff2调用的是拷贝构造函数

将代码改为以下

1
2


 CharBuffer buff1(99);
 CharBuffer buff2 = std::move(buff1) ;

此时buff1调用的是普通构造函数，buff2调用的是移动构造函数，在此场景中std::move()等价于static_cast<CharBuffer&&>

1

std::move()

上面的move函数的作用是将传入的参数转换为右值引用并返回，在上面的场景中，std::move的返回的右值引用就是一个亡值（xvalue即将消亡的值）

移动语义常用的场景是智能指针的unique_ptr的控制权转移，另一个常见场景是在通用模板库中，例如std::vector就支持移动语义，方便将右值的指针等转移到容器里

完美转发

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


void f(const string& s ) {
	cout << "左值:" << s << endl ;
}

void f(string&& s) {
	cout << "右值:" << s << endl ;
}

void g(const string& s) {
	f(s);
}

void g(string&& s) {
	f(s);
}

int main() {
 g(string("HelloWorld"));
 string s1("helloworld");
 g(s1);
}

输出的结果为

1
2


左值:HelloWorld
左值:helloworld

注意右值引用前面不要加const 右值引用的核心目的是“窃取资源”（Move）。如果加上 const，就无法修改它，也就无法把它的内部资源（如指针）置空，这就退化成了普通的拷贝，失去了移动的意义。

原因在于不管实参的类型是什么，在函数体内这个函数是具有名称的局部变量（可以获取地址），即s是一个左值，要实现调用想要的右值版本函数，需要加上参数转换

1
2
3
4
5
6


void g(const string& s) {
	f(static_cast<const string&>(s));
}
void g(const string&& s) {
	f(static_cast<const string&&>(s));
}

这样写在参数多的时候会引起重载函数几何式的增长，正确的最佳实践应该如下

1
2
3
4


template<class T>
void g(T&& v) {
	f(std::forward<T>(v));
}

这种模板参数的右值引用形式被称为 万能引用或者转发引用（Universal Reference），这并不是真正的右值引用，它既可以绑定左值，也可以绑定右值（只有当这种形式作为函数形参的类型时才能被叫做万能引用，若出现在函数体代码中，则不是万能引用）

函数模板的类型参数会在实例化时根据传入的实参类型被推导出相应的类型，而模板参数的右值引用形式遵循特殊的类型推导规则：

在传入的参数为右值时，推导出的函数参数为右值引用（T&& = 右值引用），模板参数T会被推导为实参类型（T=实参类型）即T为原始类型

在传入的参数为左值时，模板参数T会被推导为实参类型的引用（T=实参类型引用）

这段代码在传入的参数为右值时，推导出的函数参数为右值引用（T&& = 右值引用），T=string即模板参数T会被推导为实参类型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


g(string("HelloWolrd"));

template<class T>
void g(T&& v) {
	f(std::forward<T>(v));
}

//实例化
void g<string>(string&& v) {
	f(std::forward<string>(v));
}

当传入的参数为左值时，模板参数T会被推导为实参类型的引用，即T=string&

在C++语法中引用的引用是不被允许的，由此引出的会是引用折叠规则

引用折叠规则

T & &	T &
T & &&	T &
T && &	T &
T && &&	T &&

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


string s1("helloworld");
g(s1);

template<class T>
void g(T&& v) {
	f(std::forward<T>(v));
}

//实例化
void g<string&>(string & && v) {
	f(std::forward<string&>(v));
}
//折叠后
void g<string&>(string& v) {
	f(std::forward<string&>(v));
}

再来看forward函数

1
2
3
4
5


template<typename T>
T && forward(typename std::remove_reference<T>::type& t) noexcept{
	return static_cast<T&&>(t);
}
//这里的remove_reference是去引用的作用

对于forward，当传入的T是string时，实例化会是

1
2
3


string && forward<string>(string& t) noexcept{
	return static_cast<string&&>(t);
}

此时返回的是传入值t原本参数类型的右值引用（将t强制转换为右值），实现的效果是将右值引用转换为右值（需要注意，右值引用是一个左值）

若传入的T是左值引用string&（根据引用折叠化简），实例化会是

1
2
3


string& forward<string&>(string& t) noexpect{
	return static_cast<string&>(t);
}

也就是此时forward函数返回了传入值t的左值引用

总结，通过使用模板的万能引用结合std::forward函数实现参数在调用过程中按照参数原有类型进行传递，这就是完美转发的大致原理

左值右值与完美转发的总结

1. 左值 (Lvalue) vs 右值 (Rvalue)

判断左值和右值，最简单的方法是看**“它是否有名字”以及“你能否取它的地址”**。

左值 (Lvalue)：
- 特征：有名字、在内存中有固定地址、生命周期长（超过当前语句）。
- 比喻：永久居民。你叫得名字，找得到家。
- 例子：int a = 10; 中的 a。
右值 (Rvalue)：
- 特征：没名字（或是临时的）、通常不能取地址、生命周期短（用完即弃）。
- 比喻：过客。用完就销毁的临时工。
- 例子：10、x + y 的结果、string(“hello”) 构造出的临时对象。

2. 左值引用 vs 右值引用

引用就是别名。

左值引用 (T&)：只能绑定到左值。
右值引用 (T&&)：只能绑定到右值。它的存在是为了给将死的临时对象续命，或者为了窃取它的资源。

3.完美转发

完美转发要解决的问题是：当函数作为“中间商”传递参数时，参数的“左/右值属性”会丢失。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


void real_func(int& a)  { cout << "左值处理"; }
void real_func(int&& a) { cout << "右值处理"; }

// 中间商函数
template<typename T>
void wrapper(T&& arg) {
    // 问题在这里：
    // arg 虽然类型可能是 int&&，但在 wrapper 函数体内，
    // arg 是一个有名字的变量！有名字 = 左值！
    real_func(arg); 
}

int main() {
    int a = 10;
    wrapper(a); // 传入左值
    wrapper(10); // 传入右值 -> wrapper 内部 arg 变成了左值 -> 调用 real_func(int&) -> 错误！
}

结论：无论你传给 wrapper 的是左值还是右值，只要到了 wrapper 内部，参数 arg 永远是左值。如果不用完美转发，永远调用的都是 real_func 的左值版本。

4. 万能引用 (Universal Reference / Forwarding Reference)

C++11 规定：如果一个模板参数的类型是 T&&，且 T 是需要推导的，那么它就不是单纯的“右值引用”，而是万能引用。 推导规则（牢记）：

传入左值：T 被推导为 Type&。
传入右值：T 被推导为 Type (即原始类型)。

5. 引用折叠 (Reference Collapsing)

既然 T 可能被推导为引用，那 T&& 就会出现 Type& && 这种奇怪的东西。C++ 编译器会进行“折叠”：

只要遇到一个 & (左值引用)，结果就是左值引用。
只有两个都是 && (右值引用)，结果才是右值引用。


推导出的 T	代码中的 T&&	折叠后的真实类型	这里的 arg 是左值还是右值引用?
string& (传入左值)	string& &&	string&	左值引用
string (传入右值)	string &&	string&&	右值引用

6. std::forward

即使通过万能引用和引用折叠，我们得到了正确的类型（是 string& 还是 string&&），但在 wrapper 函数体内，变量 arg 本身依然是左值（因为它有名字）。

我们需要一种机制：

如果 T 是左值引用，把 arg 保持为左值。
如果 T 是非引用（即推导自右值），把 arg 强制转换为右值（等价于 std::move）。

这就是 std::forward<T> 做的事情。 std::forward 的实现逻辑（伪代码）：

1
2
3
4
5


// 简化理解版
template<typename T>
T&& forward(typename remove_reference<T>::type& arg) {
    return static_cast<T&&>(arg);
}

场景演练 1：传入左值 s

wrapper(s) 被调用。
T 推导为 string&。
std::forward<string&>(arg) 被调用。
返回 static_cast<string& &&>(arg) -> 折叠为 static_cast<string&>(arg)。
结果：还是左值。

场景演练 2：传入右值 move(s) 或临时对象

wrapper(move(s)) 被调用。
T 推导为 string。
std::forward<string>(arg) 被调用。
返回 static_cast<string&&>(arg)。
结果：强制转换为右值引用（即右值）。

总结

完美转发

万能引用 (T&&)：负责根据实参，把 T 推导成“包含左/右值信息”的类型（Type& 或 Type）。
引用折叠：负责处理 & 和 && 的冲突，确定参数 arg 的最终类型。
std::forward<T>：负责在最后一步，根据 T 的类型，决定是否要对 arg 进行 static_cast<Type&&> (即 move)。如果 T 是左值引用，它就不转；如果 T 是普通类型，它就强转为右值。

函数封装与绑定

std::function是一个通用的多态函数封装器，可将函数指针，函数对象，lambda函数等进行封装

在std中std::function用到的是定义是类模板的部分特化，如下

1
2
3


template< class R , class ... Args>
class function<R(Args...)>
//函数返回类型R，和参数类型Args

实际使用如下

1
2
3
4
5


double multiply(double a ,double b) {
	return a*b ;
}

std::function<double(double,double)> func = multiply ;

注意封装类的成员函数（同样也针对于封装类的普通成员）时，需要传入类的引用

1
2
3


std::function<float(MyClass&,float)> mf = &MyClass::f ;
MyClass myclass(1.0,2.0);
float res = mf(myclass,5);

std::function实现了类型擦除的模式，将不同类型的函数实现统一的封装接口

对于封装类的成员，可以使用std::mem_fn

1
2


template<class M , class T>
mem_fn(M T::* pm) noexpect;

参数是指向类成员的指针，返回值是一个可调用的包装器，使用方式如下

1
2
3


MyClass myclass;
auto memfun = std::mem_fn(&MyClass::f);
flaot res = memfn(myclass,3.2);

std::bind是一个函数模板，用来生成一个函数调用的转发包装器，即一个函数对象，调用该包装器时，就相当于调用它所包装的函数或者对象，并使用args作为函数的参数

1
2


template<class F , class... Args>
bind( F&& f ,Args&&... args )

注意，这里用的是右值引用

使用例子如下

1
2


auto f = std::bind(sum,1,2);
int res = f();

调用时，用的是指定的参数，也可以用占位符来代替未被指定的参数（占位符为std::placeholder）

1
2


auto f = std::bind(sum,1,std::placeholder::_1);
int res = f(5);

需要注意，此处的绑定的是绑定的右值引用，实现的效果是传递值

一句话总结，就是与参数绑定，形成一个新的可调用对象

常量表达式和constexpr

函数式编程

【现代C++】函数式编程优雅实现信号槽_哔哩哔哩_bilibili