C++11 - std::function简要介绍以及可包装函数的几种形式总结

最新推荐文章于 2024-08-19 16:29:32 发布
最新推荐文章于 2024-08-19 16:29:32 发布
阅读量3.1k 收藏 12
点赞数 1
分类专栏： C++ 文章标签： c++ stdfunction
本文为博主原创文章，未经博主允许不得转载，如需转载请先得到博主的同意，如需疑问，请联系stubbornhuang@qq.com，也可以加入计算机图形图像群526867211，以及访问我的个人站点：www.stubbornhuang.com，谢谢。
本文链接：https://blog.csdn.net/HW140701/article/details/108776293
版权

文章目录

1 std::function

函数模板形式：

template <class T>函数；//未定义
模板<class Ret，class ... Args> class function <Ret（Args ...）>;

1.1 函数模板说明

std::function是一个函数包装器模板，该函数包装器模板可以包装任意可以调用的元素，其包装器的类型只依赖于其调用特征，而不依赖于可调用元素自身的类型。

std::function可包装下列可调用元素类型：

  • 函数
  • 函数指针
  • 类成员函数
  • 任意类型的函数可调用对象（比如重载了operator（）操作符并且拥有函数闭包的函数体对象）
  • …

std::function对象可被拷贝和转移，并且可以使用指定的调用特征来直接调用目标元素。
当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。

1.2 模板参数说明

  • T ： 通用类型，但实际通用类型模板并没有被定义，只有当T的类型为形如Ret(Args…)的函数类型才能工作；
  • Ret ：调用函数返回值的类型；
  • Args：函数参数类型，对于指向成员函数的指针，第一个参数应该是指向该成员函数的引用或者对象。

2 std::function可包装的几种函数形式总结

2.1 包装普通函数和静态函数

2.1.1 非模板类型

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

int Add(int a, int b)
{
        std::cout << "普通函数被调用，结果为:" << a + b << std::endl;
        return a + b;
}

static int StaticAdd(int a, int b)
{
        std::cout << "静态函数被调用，结果为:" << a + b << std::endl;
        return a + b;
}


int main()
{
        // 1 普通函数
        std::function<int(int, int)> addFunc1 = Add;
        addFunc1(1, 2);

        // 2 普通函数指针
        std::function<int(int, int)> addFunc2 = &Add;
        addFunc2(3, 4);

        // 3 静态函数
        std::function<int(int, int)> staticAddFunc1 = StaticAdd;
        staticAddFunc1(5, 6);

        // 4 静态函数指针
        std::function<int(int, int)> staticAddFunc2 = &StaticAdd;
        staticAddFunc2(7, 8);

        getchar();
        return 0;
}

2.1.2 模板类型

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

template <class T>
T Add(T a, T b)
{
        std::cout << "普通模板函数被调用，结果为:" << a + b << std::endl;
        return a + b;
}

template <class T>
static T StaticAdd(T a, T b)
{
        std::cout << "静态模板函数被调用，结果为:" << a + b << std::endl;
        return a + b;
}


int main()
{
        // 1 普通函数
        std::function<int(int, int)> addFunc1 = Add<int>;
        addFunc1(1, 2);

        // 2 普通函数指针
        std::function<int(int, int)> addFunc2 = &Add<int>;
        addFunc2(3, 4);

        // 3 静态函数
        std::function<int(int, int)> staticAddFunc1 = StaticAdd<int>;
        staticAddFunc1(5, 6);

        // 4 静态函数指针
        std::function<int(int, int)> staticAddFunc2 = &StaticAdd<int>;
        staticAddFunc2(7, 8);

        getchar();
        return 0;
}

2.2 包装类成员函数和类静态函数

2.2.1 非模板类型

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

class A
{
public:
        typedef std::shared_ptr<A> ptr;
        A()
        {
        };
        virtual~A()
        {

        };
public:
        int A_Add_Public(int a, int b)
        {
                std::cout << "类公有成员函数被调用，结果为：" << a + b << std::endl;
                return a + b;
        }

        static int A_Add_Static(int a, int b)
        {
                std::cout << "类静态函数被调用，结果为：" << a + b << std::endl;
                return a + b;
        }

public:
        int m_Value = 20;
};


int main()
{
        // 1 类公有成员函数
        A m_a;
        std::function<int(int, int)> addFunc1 = std::bind(&A::A_Add_Public, &m_a, std::placeholders::_1, std::placeholders::_2);
        addFunc1(1, 2);

        // 2 类静态函数
        std::function<int(int, int)> addFunc2 = &A::A_Add_Static;
        addFunc2(1, 2);

        getchar();
        return 0;
}

2.2.2 模板类型

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

class A
{
public:
        typedef std::shared_ptr<A> ptr;
        A()
        {
        };
        virtual~A()
        {

        };
public:
        template <class T>
        T A_Add_Public(T a, T b)
        {
                std::cout << "类公有模板成员函数被调用，结果为：" << a + b << std::endl;
                return a + b;
        }

        template <class T>
        static T A_Add_Static(T a, T b)
        {
                std::cout << "类静态模板函数被调用，结果为：" << a + b << std::endl;
                return a + b;
        }

public:
        int m_Value = 20;
};


int main()
{
        // 1 类公有成员函数
        A m_a;
        std::function<int(int, int)> addFunc1 = std::bind(&A::A_Add_Public<int>, &m_a, std::placeholders::_1, std::placeholders::_2);
        addFunc1(1, 2);

        // 2 类静态函数
        std::function<int(int, int)> addFunc2 = &A::A_Add_Static<int>;
        addFunc2(1, 2);

        getchar();
        return 0;
}

2.3 包装Lambda表达式

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;


int main()
{
	// 1 lambda表达式
	std::function<int(int, int)> addFunc1 = [](int a, int b) ->int {
		std::cout << "lambda表达式被调用，结果为：" << a + b << std::endl;
		return a + b;
	};
	addFunc1(1, 2);

	getchar();
	return 0;
}

2.4 包装类重载操作符()函数

2.4.1 非模板类型

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

class A
{
public:
        typedef std::shared_ptr<A> ptr;
        A()
        {
        };
        virtual~A()
        {

        };
public:
        int operator()(int a, int b)
        {
                std::cout << "类重载操作符（）函数被调用，结果为：" << a + b << std::endl;
                return a + b;
        }

public:
        int m_Value = 20;
};


int main()
{
        // 1 类重载操作符（）函数
        std::function<int(int, int)> addFunc1 = A();
        addFunc1(1, 2);

        getchar();
        return 0;
}

2.4.2 模板类型

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

template <class T>
class A
{
public:
        typedef std::shared_ptr<A> ptr;
        A()
        {
        };
        virtual~A()
        {

        };
public:
        T operator()(T a, T b)
        {
                std::cout << "类重载操作符（）模板函数被调用，结果为：" << a + b << std::endl;
                return a + b;
        }

public:
        int m_Value = 20;
};


int main()
{
        // 1 类重载操作符（）函数
        std::function<int(int, int)> addFunc1 = A<int>();
        addFunc1(1, 2);

        getchar();
        return 0;
}

2.5 包装类共有成员变量

代码示例：

#include <iostream>
#include <functional>
#include <memory>

using namespace std;

class A
{
public:
        typedef std::shared_ptr<A> ptr;
        A()
        {
        };
        virtual~A()
        {

        };
public:
        int Add()
        {
                return m_Value;
        }

public:
        int m_Value = 20;
};


int main()
{
        // 1 类共有成员变量
        std::function<int(A&)> A_Value = &A::m_Value;

        A m_a;
        std::cout << "m_a对象的成员m_Value的值为：" << A_Value(m_a) << std::endl;


        getchar();
        return 0;
}

大家有兴趣可以访问我的个人站：http://www.stubbornhuang.com

HW140701
关注
专栏目录
C++11 可调用对象包装器--std::function使用
二进制君
12-05 1万+
文章目录1. std::function介绍2. std::function的原型3. std::function的用法4. std::function使用注意事项5.std::function结合typedef定义函数类型--回调应用6. std::bind 介绍 1. std::function介绍 std::function本质是一种类模板，是对通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函
C++11：std::function(包装器/适配器）
m0_66182473的博客
06-29 648
《C++ Primer》笔记
typedef std::function与bind，placeholder
最新发布
weixin_47755728的博客
08-19 292
创建了一个名为 fun_t的类型别名，该别名表示一个接受两个整数参数并返回一个 int 的函数类型。: 这部分定义了 func1类型别名所代表的函数类型的签名。具体来说，它是一个接受两个整数参数并返回一个void的函数类型。它允许你为一个已存在的类型创建一个新的、易于使用的名称。myFunction 是一个函数类型别名的变量，可以用来调用一个接受两个整数参数并返回一个整数的函数。function: 这部分指定了要创建的类型别名的名称。这段代码是C++中用于。
C++ std::function的用法
qq_23350817的博客
05-09 5750
类模版std::function是一种通用、多态的函数封装。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。std::function对象是对C++中现有的可调用实体的一种类型安全的包裹（我们知道像函数指针这类可调用实体，是类型不安全的）。 通常std::function是一个函数对...
一个function里调用另一个function_走进C++11（二十三） 函数对象包装器之std::function...
weixin_39825105的博客
12-01 555
std::function 是C++11中又一个新的概念。想想在之前的C++中，function一直是一个尴尬的存在，它作为程序的一部分，被“钉死”在程序的代码段，而且可调用的对象五花八门。C++11打破了这个尴尬，统一可调用对象的概念，可调用对象有以下几种定义：是一个函数指针，参考 C++ 函数指针和函数类型；是一个具有operator()成员函数的类的对象；可被转换成函数指针的类...
c++11 std::function 函数包装器 用法（ 参考书 《深入应用c++11》）
真诚是一种高品质的生活方式
07-15 384
std//装入一个普通函数stdfoo_func;//装入一个类的静态函数Barbar;fr2=bar;//Bar是一个仿函数对象，fr2装入一个仿函数对象就像它的名字函数包装器一样，它就像一个统一样式的包装袋，把各种不同的函数对象放进去后，方便统一的保存和调用。因此，在书中，将这个功能放到了“使用c++11让程序更简洁、更现代”来介绍。stdfunction是一个类模板，可以容纳除了类成员（函数）指针之外的所有可调用对象。.........
C++ 标准库中 function 类型
编程猿来如此
03-09 1792
C++ 标准库中 function 类型
C++ function类模板
芒种、的博客
01-09 1509
一、std::function 简介 类模板std :: function是一个通用的多态函数包装器。 std :: function的实例可以存储，复制和调用任何可调用的目标 ：包括函数，lambda表达式，绑定表达式或其他函数对象，以及指向成员函数和指向数据成员的指针。当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。 二、function类模板 template< class R, clas
C++入门学习：std::function，std::bind，std::placeholders
m0_67254672的博客
02-28 1832
std::function 是一个模板类。作用是对C++中的可调用对象进行包装，包括普通函数、成员函数、模板函数、静态函数、lambda表达式等。它的最基本的作用是，简化调用的复杂程度，统一调用的方式。声明方式：std::function< 返回值类型 ( 参数类型1, 参数类型2, ...) >
C++ function 表达式
dongdonglele521的博客
01-22 525
C++ 提供了多个包装器，这些对象用于给其他编程接口提供一致或更好的接口，接下来介绍包装器function及其解决的问题。先看一组代码： #include <iostream> template<typename T,typename F> T use_f(T v, F f) { static int count = 0; count++; std::co...
使用std::function包装类成员函数
热门推荐
G4N3
04-01 1万+
std::function std::function是一个函数包装器模板，最早来自boost库，对应其boost::function函数包装器。在c++11中，std::function能包装任何类型的可调用元素，可以包装：函数、函数指针、类成员函数指针或任意类型的函数对象。 包装类成员函数示例 #include <functional> #include <iostream&...
C++：std::function模板类
C++ JAVA的专栏
01-04 1805
C++：std::function模板类
【C++】C++使用std::function传递成员函数
愿岁并谢，与长友兮
03-06 8941
在C++中，使用std::function<>直接可传递函数地址。如下，使用DoFunc函数传递匿名函数并调用： void DoFunc(std::function<void(int,int)>func){ func(10,15); } int main(){ std::function<void(int,int)>callbackFunc = [](int number,int number2){ std::cout<<
std::function
混沌的博客
11-04 1254
std::function是一个通用多态函数包装器，该函数包装器模板能包装任何类型的可调用元素（callable element），例如普通函数，函数指针，成员函数（静态和非静态）和函数对象。 Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::funct...
C++ std::function
搬砖
06-07 1745
c++ std::function
std::function详解
mj348940862的博客
04-09 3676
std::function是一个函数包装模板，可以包装下列这几种可调用元素类型：函数、函数指针、类成员函数指针或任意类型的函数对象（例如定义了operator()操作并拥有函数闭包）。std::function对象可被拷贝和转移，并且可以使用指定的调用特征来直接调用目标元素。当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。
C++11 std::function
weixin_51795597的博客
11-02 479
std::function是C++11中的一个模板类，它是一种可调用对象的封装器，可以将各种可调用对象(如函数、函数指针、函数对象、lambda表达式)作为参数类型，并将他们存储在对象内部，从而实现对这些可调用对象的封装和管理。
std::function和std:bind详解例子
07-15
### 回答1： std::function是C++11中的一个函数对象包装器，它可以用来封装各种可调用实体，包括函数指针、函数对象以及类成员函数等。它的主要作用是将函数或者函数对象存储起来，以便稍后调用。 std::function的使用方法很简单，首先需要声明一个std::function对象，然后通过赋值或者绑定一个可调用实体来进行初始化。在调用时，可以像调用普通函数一样使用该std::function对象。 例如，假设我们有一个函数func，它的参数是一个int类型的整数，返回值是一个字符串。我们可以先定义一个std::function对象funcWrapper，然后将func赋值给它，接着通过调用funcWrapper来使用func。 std::bind是C++11中的一个函数对象适配器，它可以用来修改或者重排函数的参数顺序。它接受一个可调用实体以及一系列参数，然后返回一个新的函数对象。这个新的函数对象可以像原始的可调用实体一样进行调用。 std::bind的使用方法也很简单，首先需要声明一个std::function对象，然后使用std::bind将可调用实体以及参数绑定到该std::function对象上。在调用时，可以像调用普通函数一样使用该std::function对象。 例如，我们有一个函数add，它接受两个整数作为参数，返回它们的和。我们可以使用std::bind将add函数绑定到一个std::function对象上，并将其中一个参数设置为常数10。然后，在调用时，我们只需要提供另一个参数即可。 综上所述，std::function和std::bind是C++11中非常有用的函数对象封装器和函数对象适配器。它们可以帮助我们更灵活地处理函数对象，并且可以简化代码的编写和阅读。 ### 回答2： std::function和std::bind是C++11中引入的函数对象的概念和相关功能的标准库组件。 首先，std::function 是一个通用的函数封装器，可以包装各种可调用对象，比如普通函数、函数指针、成员函数、lambda表达式等。通过使用std::function，我们可以像使用普通函数一样，对这些可调用对象进行传递、存储等操作。例如： ```cpp #include <iostream> #include <functional> void printHello() { std::cout << "Hello\n"; } int add(int a, int b) { return a + b; } int main() { std::function<void()> func1 = printHello; func1(); // 输出 Hello std::function<int(int, int)> func2 = add; std::cout << func2(1, 2) << std::endl; // 输出 3 return 0; } ``` 其次，std::bind 是一个函数适配器，可以将可调用对象与其参数进行绑定，生成一个新的可调用对象。通过使用std::bind，我们可以将函数的部分参数绑定为特定的值，从而修改函数的行为或者改变函数的接口。例如： ```cpp #include <iostream> #include <functional> void printSum(int a, int b) { std::cout << "Sum: " << a + b << std::endl; } int main() { auto bindFunc = std::bind(printSum, 1, std::placeholders::_1); bindFunc(2); // 输出 Sum: 3 return 0; } ``` 在上面的例子中，使用std::bind将printSum函数的第一个参数绑定为1，生成了一个新的可调用对象bindFunc。当调用bindFunc(2)时，实际上就是调用了printSum(1, 2)，输出了"Sum: 3"。 通过使用std::function和std::bind，我们可以更加灵活地处理函数对象和参数的相关操作，增强了C++中函数式编程的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

HW140701

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

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

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

打赏作者

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

抵扣说明：

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

余额充值