手把手教你实现一个function模板

最新推荐文章于 2024-03-23 07:00:00 发布
最新推荐文章于 2024-03-23 07:00:00 发布
阅读量492 收藏 2
点赞数
分类专栏： C++特性 文章标签： c++函数模板 模板特化 模板重载 function模板 boost function
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43354152/article/details/128332271
版权

1.实现function需要用到的相关技术

建议看本文之前，需要先了解C++11 function或者boost::function模板的基本用法，也最好看一下我的另外一篇文章：
c++11 function模板：模板特化与可变参数函数模板

如果你使用过C++11 function模板或者boost :: function， 你一定会惊讶于这个模板对函数回调带来的方便，可能也会好奇这个功能到底是怎么实现的。我觉得还是有必要研究一下背后的实现原理，因为这背后的实现用到了很多C++语言编程骚操作（语言特性和技巧）。主要体现在如下几个方面：

  • 函数对象（仿函数）
  • 虚函数与多态
  • 模板技术
  • 函数重载
  • 不定模板参数

2.function实现

2.1 公共接口的实现

实现一个抽象基类，作为调用的接口，然后从这个积累派生出几个不同的子类，从而实现对不同形式的调用。考虑到调用的函数的参数是不确定的，因此采用了不定模板参数。

// 模板参数R 表示函数的返回值类型
// 模板参数Arg 表示函数的入参类型
template <typename R, typename... Arg> 
class invoker_base {
public:
  virtual R operator()(Arg... arg)=0;
};

2.2 实现对普通函数的调用

template <typename R, typename... Arg> 
class function_ptr_invoker 
  : public invoker_base<R,Arg...> {
    typedef R (*funcType)(Arg...);
    funcType func_;
public:
    function_ptr_invoker(funcType func):func_(func) {}
    // 重写基类的调用接口，用于对普通函数的调用
    R operator()(Arg... arg) {
        return (func_)(arg...);
    }
};

2.3 实现对函数对象的调用

// 处理函数对象的版本
template <typename R, typename Arg, typename T> 
class function_object_invoker : 
  public invoker_base<R,Arg> {
    T t_;
public:
    function_object_invoker(T t):t_(t) {}
	// 重写基类的调用接口，用于对函数对象调用
    R operator()(Arg arg) {
        return t_(arg);
    }
};

2.4 实现对成员函数的调用

// 实现对类成员函数的调用
template <typename R, typename T, typename... Arg> 
class member_ptr_invoker : 
    public invoker_base<R,Arg...> {
    typedef R (T::*memfuncType)(Arg...);
    memfuncType func_;
    T* t_;
public:
    member_ptr_invoker(memfuncType func,T* t)
        :func_(func),t_(t) {}
	// 重写基类的调用接口，用于对类成员函数的调用
    R operator()(Arg... arg) {
        return (t_->*func_)(arg...);
    }
};

2.5 对不同类型函数调用的测试

到目前为止，通过虚函数，实现了对普通函数、函数对象以及类成员函数的统一调用接口了，可以通过如下方法实现对不同类型的统一调用：

// 根据pBase指向的对象的不同，调用不同的函数。
// pBase可以指向保存普通函数的对象、保存类成员函数的对象或
// 保存函数对象的对象。
pBase->operator()("hello");

完整代码如下：

#include <iostream>
#include <functional>
using namespace std;

// 实现一个抽象基类，作为调用的接口，然后从这个积累派生出几个不同的子类，从而实现对不同形式的调用
template <typename R, typename... Arg> class invoker_base {
public:
    virtual R operator()(Arg... arg)=0;
};

template <typename R, typename... Arg> class function_ptr_invoker 
  : public invoker_base<R,Arg...> {
    typedef R (*funcType)(Arg...);
    funcType func_;
public:
    
    function_ptr_invoker(funcType func):func_(func) {}

    R operator()(Arg... arg) {
        return (func_)(arg...);
    }
};
// 处理函数对象的版本
template <typename R, typename T, typename... Arg> 
class function_object_invoker : 
  public invoker_base<R,Arg...> {
    T t_;
public:
    function_object_invoker(T t):t_(t) {}

    R operator()(Arg... arg) {
        return t_(arg...);
    }
};

// 实现对类成员函数的调用
template <typename R, typename T, typename... Arg> 
class member_ptr_invoker : 
    public invoker_base<R,Arg...> {
    typedef R (T::*memfuncType)(Arg...);
    memfuncType func_;
    T* t_;
public:
    member_ptr_invoker(memfuncType func,T* t)
        :func_(func),t_(t) {}

    R operator()(Arg... arg) {
        return (t_->*func_)(arg...);
    }
};
/*   用于测试的函数 */
// 测试普通函数
bool some_function(const std::string s) {
  std::cout << s << " This is a common function \n";
  return true;
}
// 测试类成员函数
class some_class {
public:
  bool some_function(const std::string s) {
    std::cout << s << " This is a member function \n";
    return true;
  }
};
// 测试函数对象
class some_function_object {
public:
  bool operator()(const std::string s) {
    std::cout << s << 
      " This is a function object \n";
    return true;
  }
};



int main()
{
    invoker_base<bool, string>* pBase;
    // 调用类成员函数
    some_class s;
    pBase = new member_ptr_invoker<bool, some_class, string>(some_class::some_function, &s);
    pBase->operator()("hello");

    // 调用普通函数
    pBase = new function_ptr_invoker<bool, string>(some_function);
    pBase->operator()("hello");

    // 调用函数对象
    some_function_object func_obj;
    pBase = new function_object_invoker<bool, some_function_object, string>(func_obj);
    pBase->operator()("hello");
    return 0;
}

打印结果：
在这里插入图片描述

2.6 对函数接口进行包装

截止到一步，显然离我们最终的目标还有些差距。虽然到目前为止，我们可以将基类指针指向不同的对象，从而实现对不同类型函数调用，但是我们最终的目的是希望模板能够根据我们传入参数的类型（普通函数、函数对象或者是成员函数）能够进行自动创建相应的对象。于是，我们要需要对接口做一些包装工作。这里主要需要用到模板的重载技术。

template <typename R, typename Arg> class function1 {
  invoker_base<R,Arg>* invoker_;
public:
  function1(R (*func)(Arg)) : 
  invoker_(new function_ptr_invoker<R,Arg>(func)) {}

  template <typename T> function1(R (T::*func)(Arg),T* p) : 
    invoker_(new member_ptr_invoker<R,Arg,T>(func,p)) {}

  template <typename T> function1(T t) : 
    invoker_(new function_object_invoker<R,Arg,T>(t)) {}

  R operator()(Arg arg) {
    return (*invoker_)(arg);
  }

  ~function1() {
    delete invoker_;
  }
};

包装之后测试如下：
注意对比与包装之前的区别。可以看到对接口包装之后，可以根据我们传入的参数类型自动创建相关类型的对象，不再需要我们自己根据类型去创建具体的不同子类对象。

invoker_base<bool, string>* pBase;
    // 调用类成员函数
    some_class s;
    // pBase = new member_ptr_invoker<bool, some_class, string>(some_class::some_function, &s);
    // pBase->operator()("hello");
    function1<bool, string> memfunc(some_class :: some_function, &s);
    memfunc("hello");

    // 调用普通函数
    // pBase = new function_ptr_invoker<bool, string>(some_function);
    // pBase->operator()("hello");
    function1<bool, string> commonfunc(some_function);
    commonfunc("hello");
    // 调用函数对象
    some_function_object func_obj;
    // pBase = new function_object_invoker<bool, some_function_object, string>(func_obj);
    // pBase->operator()("hello");
    function1<bool, string> objfunc(func_obj);
    objfunc("hello");

2.8 对接口做一些调整

不知道有没有注意到，c++11或boost::function中对模板参数的传入类型如下：

// 注意 <>内的形式 
function<bool(string)> f;

但是我们上面实现的function1模板参数的传入类型是下面这样的：

function<bool, string> f;

显示第一种形式更直观，所以我们还得最我们的实现做一些调整。
主要需要用到模板特化技术。

// 定义一个主模板
template <typename R, typename... Arg> 
class function1;
// 然后对模板参数进行特化
template <typename R, typename... Arg> 
class function1<R(Arg...)> {
   // 特化模板中的其它实现完全不变
};

经过上面的调整之后，就可以按照下面的方式使用模板了:

	// 调用类成员函数
    some_class s;
    function1<bool(string)> memfunc(some_class :: some_function, &s);
    memfunc("hello");

    // 调用普通函数
    function1<bool(string)> commonfunc(some_function);
    commonfunc("hello");

    // 调用函数对象
    some_function_object func_obj;
    function1<bool(string)> objfunc(func_obj);
    objfunc("hello");

附 完整代码

#include <iostream>
#include <functional>
using namespace std;

// 实现一个抽象基类，作为调用的接口，然后从这个积累派生出几个不同的子类，从而实现对不同形式的调用
template <typename R, typename... Arg> class invoker_base {
public:
    virtual R operator()(Arg... arg)=0;
};

template <typename R, typename... Arg> class function_ptr_invoker 
  : public invoker_base<R,Arg...> {
    typedef R (*funcType)(Arg...);
    funcType func_;
public:
    
    function_ptr_invoker(funcType func):func_(func) {}

    R operator()(Arg... arg) {
        return (func_)(arg...);
    }
};
// 处理函数对象的版本
template <typename R, typename T, typename... Arg> 
class function_object_invoker : 
  public invoker_base<R,Arg...> {
    T t_;
public:
    function_object_invoker(T t):t_(t) {}

    R operator()(Arg... arg) {
        return t_(arg...);
    }
};

// 实现对类成员函数的调用
template <typename R, typename T, typename... Arg> 
class member_ptr_invoker : 
    public invoker_base<R,Arg...> {
    typedef R (T::*memfuncType)(Arg...);
    memfuncType func_;
    T* t_;
public:
    member_ptr_invoker(memfuncType func,T* t)
        :func_(func),t_(t) {}

    R operator()(Arg... arg) {
        return (t_->*func_)(arg...);
    }
};
/*   用于测试的函数 */
// 测试普通函数
bool some_function(const std::string s) {
  std::cout << s << " This is a common function \n";
  return true;
}
// 测试类成员函数
class some_class {
public:
  bool some_function(const std::string s) {
    std::cout << s << " This is a member function \n";
    return true;
  }
};
// 测试函数对象
class some_function_object {
public:
  bool operator()(const std::string s) {
    std::cout << s << 
      " This is a function object \n";
    return true;
  }
};
template <typename R, typename... Arg> 
class function1;

template <typename R, typename... Arg> 
class function1<R(Arg...)> {
    invoker_base<R,Arg...>* invoker_;
public:
    // 对普通函数进行重载
    function1(R (*func)(Arg...)) : 
    invoker_(new function_ptr_invoker<R,Arg...>(func)) {}
    
    // 对类成员函数进行重载
    template <typename T> 
    function1(R (T::*func)(Arg...),T* p) : 
        invoker_(new member_ptr_invoker<R,T, Arg...>(func,p)) {}
    
    // 对函数对象进行重载
    template <typename T> 
    function1(T t) : 
        invoker_(new function_object_invoker<R,T, Arg...>(t)) {}
    
    // 对接口进行包装
    R operator()(Arg... arg) {
        return (*invoker_)(arg...);
    }

  ~function1() {
    delete invoker_;
  }
};

int main()
{
   
    // 调用类成员函数
    some_class s;
    function1<bool(string)> memfunc(some_class :: some_function, &s);
    memfunc("hello");

    // 调用普通函数
    function1<bool(string)> commonfunc(some_function);
    commonfunc("hello");

    // 调用函数对象
    some_function_object func_obj;
    function1<bool(string)> objfunc(func_obj);
    objfunc("hello");
    return 0;
}

参考资料：
1、boost::function用法详解
2、关于c++11 std::function的模板参数 <_Res(_ArgTypes…)>

编程砖家
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
function类模板
qq_46064962的博客
10-11 367
function类型介绍可调用对象的概念调用形式function类模板用法function使用注意问题 可调用对象的概念 可调用对象：一个类重载了（）运算符，我们就可以像调用函数一样，调用这个类的对象。也有称为“函数对象”，“仿函数”。 #include <iostream> class A{ public: A(){ std::cout << "构造函数" << std::endl; } ~A(){ std::
C++：std::function模板类
C++ JAVA的专栏
01-04 1780
C++：std::function模板类
C++ function类模板
芒种、的博客
01-09 1458
一、std::function 简介 类模板std :: function是一个通用的多态函数包装器。 std :: function的实例可以存储，复制和调用任何可调用的目标 ：包括函数，lambda表达式，绑定表达式或其他函数对象，以及指向成员函数和指向数据成员的指针。当std::function对象未包裹任何实际的可调用元素，调用该std::function对象将抛出std::bad_function_call异常。 二、function类模板 template< class R, clas
C++中的函数模板
weixin_73567058的博客
05-23 1269
函数模板是一种通用的函数描述，可以定义多个同名函数，以适应不同类型的参数。如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料类型，来获得不同材料的铸件即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。- 使用 template 关键字定义模板函数，语法为：``````- typename 是一个关键字，表示类型参数。
C++:27---function模板（functional头文件）
董哥的黑板报
07-09 5074
引入 在介绍function之前，先介绍下面的知识 有时，不同类型的对象可能共享同一种调用形式 例如下面的三种类型，都共享同一种调用形式：int(int,int); int add(int i, int j) { return i + j; } auto mod = [](int i, int j) {return i * j; }; struct divide { int o...
后端思维篇-代码封装：手把手教你写一个并行调用模板
11-17
通过以上步骤，你可以创建一个自己的并行调用模板，用于处理多个异步任务。这样的模板不仅提高了代码的复用性，也使得并行调用变得更加简单和可控。在实际项目中，根据需求调整并行调用策略，可以有效提升系统性能，...
图文并茂、手把手教你怎么将Java项目与Flex4整合
11-18
首先，你需要创建一个Java项目，例如命名为`JavaAndFlexDemo`。然后配置内嵌的Tomcat服务器，这个过程可以通过参考其他教程完成。一旦配置好，就可以开始整合Java与Flex项目了。 关键步骤是从Blazeds项目中解压`...
关于matlab中s-function参数设置的两个例子讲解详尽受益匪浅.zip
最新发布
04-20
例如，如果我们想要创建一个接受两个浮点数输入并返回一个整数输出的S-Function，我们可以设置： ```c ssSetNumInputPorts(S, 2); /* 设置两个输入端口 */ ssSetInputPortDataType(S, 0, SS_DOUBLE); /* 输入端口0...
《MATLAB的S-Function编写指导》-共100页.pdf.zip
04-19
4. **S-Function模板**：MATLAB提供了预定义的S-Function模板，可以帮助开发者快速启动项目。这些模板包含了基本框架和注释，方便用户根据自己的需求进行修改和扩展。 5. **S-Function参数**：S-Function可以接受...
C++函数模板
Jasmine-Lily的博客
11-22 3009
C++函数模板
function 函数
热门推荐
weixin_46376652的博客
04-08 2万+
一、函数的基本注意事项 function函数的名字也是一个标识符，通过关键字function申明一个函数 function 函数名(){ 代码块 } 二、函数基本用法 1、形参与实参 1、形参与实参可以有无数个，实参按照顺序赋值给形参； 2、实参个数不一定要与实参个数相同，没有实参赋值的形参默认数值为undefined； 3、arguments能够获取到实参列表的数据，也能够更改数据； 4、形参数据类型是由实参的数据类型决定； <script> fun
C++中函数对象模板function＜T＞、通用函数适配器std::bind和lambda
hanxiaoyong_的博客
01-27 1496
C++function用法、C++ std::bind用法、C++ lambda用法、using的使用、std::placeholders::_1用法
C++开发基础——函数对象与std::function模板
CoderZZ_2024的博客
03-23 2158
C++语法基础
c++函数模板
weixin_50866517的博客
04-08 1384
函数模板介绍函数模板案例普通函数与函数模板的区别普通函数与函数模板的调用规则三级标题四级标题五级标题六级标题 介绍 1.函数模板，实际上是建立一个通用函数，它所用到的数据的类型（包括返回值类型、形参类型、局部变量类型）可不具体指定，而是用一个虚拟的类型来代替（实际上是用一个标识符来占位），等发生函数调用时再根据传入的实参来逆推出真正的类型。这个通用函数就称为函数模板。 2.语法 template<typename T> 函数声明或定义 注：template:声明创建模板；typename:表明其
C++ function 类模板
weixin_42136255的博客
11-21 535
C++ function 类模板
C++ Function Templates (函数模板)
既然选择了远方 便只顾风雨兼程 - 永强
03-11 2055
C++ Function Templates (函数模板)
javascript学习之函数 function 万字详解
白话机器学习
08-08 924
JavaScript 有三种声明函数的方法。（1）function 命令function命令声明的代码区块，就是一个函数。function命令后面是函数名，函数名后面是一对圆括号，里面是传入函数的参数。函数体放在大括号里面。上面的代码命名了一个print函数，以后使用print()这种形式，就可以调用相应的代码。这叫做函数的声明（Function Declaration）。（2）函数表达式除了用function命令声明函数，还可以采用变量赋值的写法。这种写法将一个匿名函数赋值给变量。
手把手教你写一个ios app
07-28
以下是一步一步教你如何编写一个iOS应用的简要指南： 1. 了解基本知识： 在开始编写iOS应用之前，你需要了解一些基本的编程概念和iOS开发环境。学习Objective-C或Swift编程语言、熟悉Xcode集成开发环境以及掌握基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值