【c++11】包装器

最新推荐文章于 2025-04-29 16:16:24 发布
原创 最新推荐文章于 2025-04-29 16:16:24 发布 · 880 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c++

Alt

🔥个人主页：Quitecoder

🔥专栏：c++笔记仓

Alt

包装器（Wrapper） 是一个常见的编程设计模式，通常用于封装或“包装”某个现有的对象、函数、数据结构或者操作，以提供额外的功能或简化接口。在不同的上下文中，包装器可能有不同的实现方式和目的，但核心思想都是“将现有功能封装起来，以实现更强的扩展性、易用性或者功能分离”。

目录

1.function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。那么我们来看看，我们为什么需要function呢？

ret = func(x);

上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lambda表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！为什么呢？

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（可以是普通函数、函数对象或 Lambda 表达式）。
  • 一个参数 x，这个参数的类型是 T，将被传递给函数对象 f。

在这里插入图片描述

从结果可以看出，count 的值在每次调用不同 useF 时都被重置为 1，且 count 的地址在每次调用中都不同。这说明 静态变量 count 并没有在多个调用之间共享状态，而是每次调用 useF 都生成了一个独立的 count 变量。

为什么 count 的值和地址不共享？

在模板函数中，静态变量的生命周期是与模板实例相关联的。这意味着每次为不同的模板参数组合生成一个模板实例时，静态变量 count 都是独立的。

模板实例化的过程

  1. 在第一次调用 useF(f, 11.11) 时，模板参数 F 被推导为 double (*)(double)（函数指针），T 被推导为 double。这会实例化一个 useF<double (*)(double), double> 模板函数。

    • 对应的 count 是 useF<double (*)(double), double> 的静态变量，值为 1，地址为 0056B428。

  2. 在调用 useF(Functor(), 11.11) 时，模板参数 F 被推导为 Functor，T 仍然是 double。这会实例化另一个独立的模板函数 useF<Functor, double>。

    • 对应的 count 是 useF<Functor, double> 的静态变量，值为 1，地址为 0056B42C。

  3. 在调用 useF([](double d) -> double { return d / 4; }, 11.11) 时，模板参数 F 被推导为一个特定的 Lambda 类型（Lambda 表达式的类型是匿名的），T 为 double。这又会实例化一个新的模板函数 useF<LambdaType, double>。

    • 对应的 count 是 useF<LambdaType, double> 的静态变量，值为 1，地址为 0056B430。

静态变量在模板中的作用域

  • 每个模板实例的静态变量是独立的，不会共享状态。
  • 对于每一种 F 和 T 的组合，都会实例化一个独立版本的 useF 函数，其静态变量 count 也是独立的。
std::function在头文件<functional>
// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

在这里插入图片描述

他不是定义可调用对象，而是包装可定义对象
在这里插入图片描述

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)> func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;
	// lambda表达式
	function<int(int, int)> func3 = [](const int a, const int b)
		{return a + b; };
	cout << func3(1, 2) << endl;

	// 类的成员函数
	function<int(int, int)> func4 = &Plus::plusi;
	cout << func4(1, 2) << endl;
	function<double(Plus, double, double)> func5 = &Plus::plusd;
	cout << func5(Plus(), 1.1, 2.2) << endl;
	return 0;
}

类成员函数与普通函数的区别

  1. 普通函数
int f(int a, int b)
{
    return a + b;
}
  • 这是一个普通的全局函数。
  • 普通函数的调用是直接的：f(1, 2)，它不依赖于对象或者类的上下文。
  • std::function 可以直接接受普通函数指针，因此不需要加取地址符（&）来指明是函数指针。
  1. 类的静态成员函数
class Plus
{
public:
    static int plusi(int a, int b)
    {
        return a + b;
    }
    double plusd(double a, double b)
    {
        return a + b;
    }
};
  • plusi 是 静态成员函数，属于类 Plus，但它不依赖于对象实例。
  • 静态成员函数的调用方式和普通函数类似，可以通过类名直接访问 Plus::plusi，但也可以通过对象实例调用。静态成员函数的行为类似于普通的全局函数，因此它可以作为一个普通函数来传递。

为什么静态成员函数要加取地址符 &?

在调用静态成员函数时，我们通常需要通过类名来指明该函数是属于类的静态函数，而不是实例成员函数。因此，即使是静态成员函数，它也需要通过取地址符 & 来指定其指针类型。

function<int(int, int)> func4 = &Plus::plusi;
  • 这里，&Plus::plusi 是静态成员函数的指针，告诉 std::function func4 要存储的是 plusi 函数的地址。
  • 虽然 plusi 是静态成员函数，但它依然是一个函数，并且它的签名是 int(int, int)，和普通函数一样，因此我们使用取地址符 & 来获取函数指针。
  1. 类的非静态成员函数
function<double(Plus, double, double)> func5 = &Plus::plusd;
  • plusd 是一个 非静态成员函数，它依赖于类的实例来调用，因为它需要访问类实例的成员数据（如果有的话）。
  • 非静态成员函数的调用需要通过对象实例来绑定：obj.plusd(a, b)。为了将非静态成员函数作为函数指针传递，必须先提供一个对象实例来进行绑定。
为什么非静态成员函数不能直接作为函数指针传递？

非静态成员函数不是普通的全局函数，它是绑定到类的实例上的。也就是说，调用一个非静态成员函数需要一个类的实例，因此它的地址实际上是包含了实例的上下文的。这种成员函数的指针通常被称为成员函数指针，它和普通函数指针有很大的区别。

在 C++ 中，非静态成员函数必须通过对象实例来调用。例如：

Plus p;
p.plusd(1.1, 2.2);  // 通过对象 p 来调用

而在 std::function 中，传递成员函数指针时，需要额外提供一个对象实例或引用来绑定成员函数。可以通过如下方式来实现：

function<double(Plus, double, double)> func5 = &Plus::plusd;
cout << func5(Plus(), 1.1, 2.2) << endl;
  • 这里的 Plus() 是一个临时对象，它被传递给 func5 作为对象实例，从而调用 plusd 成员函数。

成员函数不能像普通函数一样直接作为指针传递，它们是绑定到对象的，因此不能直接传递函数指针。非静态成员函数需要通过对象实例来绑定，因此我们在 std::function 中也需要传递一个对象实例来确保函数能够正确调用。

#include <functional>
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;
	// lambda表达式
	std::function<double(double)> func3 = [](double d)->double { return d /
		4; };
	cout << useF(func3, 11.11) << endl;
	return 0;
}

在这里插入图片描述
包装器解决了模版实例化多份的问题

题目链接：逆波兰表达式
题目描述：在这里插入图片描述

第一种是没有包装器的做法，遇见数字加进去，遇见符号计算

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto& str:tokens)
        {
            if(str == "+" || str == "-" || str == "*" || str == "/")
            {
            int right = st.top();
             st.pop();
             int left = st.top();
             st.pop();
             switch(str[0])
             {
                 case '+':
                     st.push(left+right);
                     break;
                 case '-':
                     st.push(left-right);
                     break;
                 case '*':
                     st.push(left*right);
                     break;
                 case '/':
                     st.push(left/right);
                     break;
             }
             }

         else
         {
             // 1、atoi itoa
             // 2、sprintf scanf
             // 3、stoi to_string C++11
             st.push(stoi(str));
         }      
        }
        return st.top();
    }
};

下面是用包装器

class Solution {
public:
	int evalRPN(vector<string>& tokens) {
		stack<int> st;
		map<string, function<int(int, int)>> opFuncMap =
		{
		{ "+", [](int i, int j) {return i + j; } },
		{ "-", [](int i, int j) {return i - j; } },
		{ "*", [](int i, int j) {return i * j; } },
		{ "/", [](int i, int j) {return i / j; } }
		};
		for (auto& str : tokens)
		{
			if (opFuncMap.find(str) != opFuncMap.end())
			{
				int right = st.top();
				st.pop();
				int left = st.top();
				st.pop();
				st.push(opFuncMap[str](left, right));
			}
			else
			{
				// 1、atoi itoa
				// 2、sprintf scanf
				// 3、stoi to_string C++11
				st.push(stoi(str));
			}
		}
		return st.top();
	}
};

2.bind

std::bind 是 C++11 引入的一个函数模板，用于创建一个新的可调用对象（通常是函数对象）。这个函数对象“绑定”了原始函数的一些参数，并返回一个新的函数，可以通过新的参数进行调用。可以把它看作是部分应用（partial application）的一种实现。 std::bind 允许我们预先绑定一些参数，使得我们可以方便地创建定制化的、部分应用的函数。

基本语法

std::bind(callable, arg1, arg2, ..., argN)
  • callable：可以是普通函数、函数对象、成员函数、或者 Lambda 表达式等。
  • arg1, arg2, …, argN：是你想要绑定的参数，std::bind 会在新的函数调用时预先固定这些参数的值。

返回值

std::bind 返回一个可调用对象（通常是函数对象），该对象能够在稍后的时间接受剩余的参数并执行绑定函数。

常见用法示例

1. 绑定普通函数的参数

假设我们有一个普通函数 add，它接受两个整数并返回它们的和：

#include <iostream>
#include <functional>  // 引入 std::bind

int add(int a, int b) {
    return a + b;
}

int main() {
    // 绑定 add 函数，第一个参数绑定为 10
    auto add10 = std::bind(add, 10, std::placeholders::_1);  // _1 表示占位符，表示等待一个新的参数
    
    std::cout << add10(5) << std::endl;  // 10 + 5 = 15
    return 0;
}

输出：

15

在这个例子中，std::bind 将 add 函数的第一个参数绑定为 10，返回一个新的函数 add10，它只需要一个参数来完成调用。std::placeholders::_1 是一个占位符，表示 add10 需要一个新的参数来替代这个占位符。

2. 绑定成员函数

如果你想绑定一个类的成员函数，需要传递一个对象实例来调用成员函数：

#include <iostream>
#include <functional>  // 引入 std::bind

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

int main() {
    Calculator calc;

    // 绑定成员函数 add，必须提供对象实例
    auto bound_add = std::bind(&Calculator::add, &calc, std::placeholders::_1, std::placeholders::_2);

    std::cout << bound_add(3, 4) << std::endl;  // 3 + 4 = 7
    return 0;
}

输出：

7

在这个例子中，我们使用 std::bind 绑定了类的成员函数 add，并指定了一个对象实例 &calc。std::placeholders::_1 和 std::placeholders::_2 表示调用时提供的两个参数。

3. 绑定成员函数与对象实例

有时你需要绑定成员函数，并且在绑定时固定对象实例，而后续调用时只需要提供其他参数。你可以通过以下方法来完成：

#include <iostream>
#include <functional>  // 引入 std::bind

class Printer {
public:
    void print(const std::string& str) {
        std::cout << "Printed: " << str << std::endl;
    }
};

int main() {
    Printer printer;

    // 绑定成员函数 print，并固定对象实例
    auto bound_print = std::bind(&Printer::print, &printer, std::placeholders::_1);

    bound_print("Hello, World!");  // 输出: Printed: Hello, World!
    return 0;
}

输出：

Printed: Hello, World!

在这个例子中，std::bind 将 Printer::print 成员函数与对象 printer 绑定，并返回一个新的函数 bound_print，该函数只需传递一个字符串参数即可。

4. 使用多个占位符

std::bind 支持多个占位符。占位符的编号从 _1 开始，用于指定参数的顺序。

#include <iostream>
#include <functional>  // 引入 std::bind

int multiply(int a, int b, int c) {
    return a * b * c;
}

int main() {
    // 绑定前两个参数，并保留最后一个参数
    auto bound_multiply = std::bind(multiply, 2, 3, std::placeholders::_1);

    std::cout << bound_multiply(4) << std::endl;  // 2 * 3 * 4 = 24
    return 0;
}

输出：

24

在这个例子中，我们将 multiply 的前两个参数绑定为 2 和 3，使用占位符 _1 表示剩余的参数，最后通过 bound_multiply(4) 提供第三个参数。

5. 绑定 Lambda 表达式

std::bind 不仅支持函数指针，还可以绑定 Lambda 表达式：

#include <iostream>
#include <functional>  // 引入 std::bind

int main() {
    // 绑定 Lambda 表达式，固定第一个参数
    auto bound_lambda = std::bind([](int a, int b) { return a + b; }, 10, std::placeholders::_1);

    std::cout << bound_lambda(5) << std::endl;  // 10 + 5 = 15
    return 0;
}

输出：

15
  1. std::bind 的核心功能：将函数、成员函数或 Lambda 表达式与一些固定的参数绑定，生成一个新的可调用对象，后续调用时可以提供剩余的参数。
  2. std::placeholders::_N：占位符用于指定绑定参数的位置，_1 表示第一个占位符，_2 表示第二个，占位符的顺序决定了参数传递的顺序。
  3. 用途：
    • 部分应用：可以在调用函数时预先固定一些参数。
    • 适应某些 API 设计：例如，事件回调、适配器设计等，需要将一部分参数绑定到函数中。
    • 结合算法使用：在 STL 算法（如 std::for_each）中，结合 std::bind 可以生成带有部分固定参数的自定义操作。
C++_包装器
安权_code的博客
03-11 1600
C++11的包装器，总称为function包装器，而包装器又称适配器，顾名思义包装器主要是用于包装函数的，实际上是将函数指针、仿函数类、lambda函数进行了又一层的封装。
C++ wrapper 关于包装器详细介绍-案例分析
qq_42279379的博客
04-03 512
c++包装器的详细分析-案例，为什么需要包装器？什么是包装器？如何使用包装器？
跟我学c++高级篇——模板元编程之四Wrapper
fpcc的专栏
01-17 4119
对c++中的Wrapper进行分析说明，并举一些例子来测试
C++的包装器
little_startoo的博客
07-01 834
C++的包装器
C++11 -- 包装器
清欢Allen的技术博客
05-30 1039
/ 原型如下： template < class Fn , class . . . Args > /* unspecified */ bind(Fn && fn , Args && . . . args);注意( 1 ): fn 指的是需要包装的对象.( 2 ): args…对应的是给定fn函数中的参数.( 1 ) callable: 需要包装的对象…( 2 ) newCallable: 生成的一个新的可调用对象.
【C++11】包装器
m0_64224788的博客
05-03 1142
C++11——包装器
C++11：包装器（适配器模式）
weixin_51142926的博客
03-31 3052
function包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。 那么function包装器究竟是为了解决什么问题呢？？C++11设置出来的初衷是什么呢？？
＜C++11＞ 包装器
prodigy623的博客
03-01 1154
C++11中function与bind包装器的讲解
【C++11】包装器：function与bind
最新发布
记录学习与成长
04-29 1124
上文我们学了C++11中一个新的表达式：Lambda表达式。Lambda表达式可以在函数内部定义，其本质是仿函数本文我们来学习C++11的下一个新语法：包装器。
C++ 包装器
2301_78985459的博客
08-24 1163
C++ 常用的两个包装器function和bind，统一可调用对象的类型和调整可调用对象的参数。
C++11——— 包装器
2021dragon的博客
09-18 4454
function包装器function是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。Ret：被包装的可调用对象的返回值类型。Args...：被包装的可调用对象的形参类型。包装示例function包装器可以对可调用对象进行包装，包括函数指针（函数名）、仿函数（函数对象）、lambda表达式、类的成员函数。
C++ 包装器，看这一篇就够了
Jasmine-Lily的博客
05-06 1960
C++ 包装器 1 简介 包装器用于给其他编程接口提供更一致或更合适的接口。 模板bind可替代bind1st和bind2nd，且更灵活 模板mem_fn让您能够将成员函数作为常规函数进行传递 模板reference_wrapper让您能够创建像引用但可被复制的对象 包装器function让您能够以统一的方式处理多种类似于函数的形式 模板function是在头文件functional头文件中声明的，他从参数和返回值的角度定义了一个对象，可用于包装调用参数和返回值相同的函数指针、伪函数或lambda表达式
C++包装器（functional&&bind）
yue152152的博客
10-13 1741
什么类可以同时接收函数指针、仿函数、lambda表达式呢？看看包装器 如何改变函数的参数个数？ 其中讲解了逆波兰表达式用包装器解决的案例
C++11：包装器
Man9o
03-09 1516
C++ 包装器是一种用于给其他编程接口提供更一致或更合适的接口的技术。它可以包装任何类型的可调用实体，如普通函数，函数对象，lambda表达式、类的成员函数等。C++ 包装器有多种类型，如bind, mem_fn, reference_wrapper, function等。包装器的本质是一种类模板，它可以提高模板的效率，简化代码，增强可读性和可维护性。下面介绍C++中的两种包装器：function包装器和bind包装器。Ret：被包装的可调用对象的返回值类型。Args...
C++笔记---包装器
2302_80372340的博客
11-10 1080
C++中的包装器是一种设计模式，用于将一个复杂或底层的接口进行封装，以便提供一个更简洁、易用的接口。包装器可以包装任何类型的可调用实体，如函数，成员函数，函数指针，仿函数对象，lambda表达式等。包装器在资源管理、接口封装、类型安全等方面有广泛应用。在实际编程中，包装器可以用于回调机制、事件处理、异步编程等场景。它们提供了灵活的函数调用机制，使得代码更加模块化和可重用。综上所述，C++包装器是提升代码可读性、可维护性和性能的有力工具。
【C++11】—— 包装器
M的博客
01-15 2204
【C++11】—— 包装器。
【C++11】C++11——包装器
weixin_60478154的博客
03-22 1107
【C++】C++11——包装器
【C++】C++11 包装器
℉f的博客
04-22 2098
我们目前学习过的可调用对象有三种：函数指针、仿函数以及lambda表达式（实际上也是仿函数），但是这三种可调用对象却又有各自的缺点，比如函数指针类型写起来比较复杂，仿函数的类型不统一，而lambda表达式语法层上就没有类型，所以C++11引入了包装器，主要就是为了封装他们，统一类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

QuiteCoder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值