18.手写一个function模板函数

最新推荐文章于 2024-08-09 10:25:03 发布
最新推荐文章于 2024-08-09 10:25:03 发布
阅读量607 收藏
点赞数 23
分类专栏： c++ 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62318955/article/details/134474811
版权

手写一个function模板函数

实现需求：

​ 使如下代码可以正常运行：

#include <iostream>

using namespace std;

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

class ADD_MULT {
public:
    ADD_MULT(int x) : x(x) {}
    int operator() (int a, int b) {
        return (a + b) * 2;
    }
    int x;
};

int main() {
    ADD_MULT add_mult(2);
    function<int(int, int)> f1 = add;
    function<int(int, int)> f2 = add_mult;
    cout << f1(3, 4) << endl;
    cout << f2(3, 4) << endl;
    f1 = f2;
    cout << f1(3, 4) << endl;
    f1 = add;
    f2 = add_mult;
    cout << f1(3, 4) << endl;
    cout << f2(3, 4) << endl;
    return 0;
}

实现：function<int(int, int)>模板样式：

template<typename T, typename ...ARGS> class function {};
template<typename T, typename ...ARGS>
class function<T(ARGS...)> {
public:
    
};

这里使用模板的偏特化，来实现需求

实现：构造函数（可以接收普通函数，也可以接收对象）

我们想要用同一个数据类型来同时接受两种不同的对象，这里就得使用**继承（接口）**来实现，

template<typename T, typename ...ARGS>
class BASE {
public:

};

template<typename T, typename ...ARGS>
class normal_function : public BASE<T, ARGS...> {
public:

};

template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:

};

template<typename T, typename ...ARGS> class function {};
template<typename T, typename ...ARGS>
class function<T(ARGS...)> {
public:
    function(T (*ptr)(ARGS...)) : ptr(new normal_function<T, ARGS...>(ptr)) {}
    template<typename U>
    function(U &u) : ptr(new B<U, T, ARGS...>(&u)) {}

private:
    BASE<T, ARGS...> *ptr;
};

​ 这里我们可以使用BASE类来同时接受不同函数和对象。并且由于对象的类型是不确定的，所有我们得在类对象的构造函数上面加上模板，来处理这种情况。

普通函数的构造函数：

template<typename T, typename ...ARGS>
class normal_function : public BASE<T, ARGS...> {
public:
    normal_function(T (*ptr)(ARGS...)) : ptr(ptr) {}

private:
    T (*ptr)(ARGS...);
};

​ 我们在这里定义一个函数指针，来接收我们函数地址，并进行初始话。

类对象的构造函数：

template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:
    B(U *u) : u(u), ptr(&U::operator()) {}

private:
    U *u;
    T (U::*ptr)(ARGS...);
};

​ 我们这里定义了一个指针对象，用来记录对象的地址，并定义了一个指向成员函数的指针（因为是虚函数，所有用虚函数表），来记录成员函数的地址。

​ 到这里我们就实现了如何同一个数据类型来同时接受两种不同的对象，也就是主函数中的这段代码：

	function<int(int, int)> f1 = add;
    function<int(int, int)> f2 = add_mult;

实现cout << f1(3, 4) << endl;

template<typename T, typename ...ARGS>
class BASE {
public:
    virtual T run(ARGS...) = 0;
};

template<typename T, typename ...ARGS>
class normal_function : public BASE<T, ARGS...> {
public:
    normal_function(T (*ptr)(ARGS...)) : ptr(ptr) {}
    T run(ARGS... args) override {
        return ptr(forward<ARGS>(args)...);
    }

private:
    T (*ptr)(ARGS...);
};

template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:
    B(U *u) : u(u), ptr(&U::operator()) {}
    T run(ARGS... args) override {
        return (u->*ptr)(forward<ARGS>(args)...);
    }

private:
    U *u;
    T (U::*ptr)(ARGS...);
};

template<typename T, typename ...ARGS> class function {};
template<typename T, typename ...ARGS>
class function<T(ARGS...)> {
public:
    function(T (*ptr)(ARGS...)) : ptr(new normal_function<T, ARGS...>(ptr)) {}
    template<typename U>
    function(U &u) : ptr(new B<U, T, ARGS...>(&u)) {}
    T operator()(ARGS... args) {
        return ptr->run(args...);
    }

private:
    BASE<T, ARGS...> *ptr;
};

这里我们就可以用继承来实现各自的输出：

​ 代码中，BASE 类是一个纯虚基类，定义了一个 run 方法，但没有提供具体的实现。normal_function 和 B 类分别继承自 BASE，并提供了 run 方法的具体实现。

  • 在 normal_function 类中，run 方法直接调用了存储的普通函数指针，并将传入的参数通过 forward 转发给该函数。
  • 在 B 类中，run 方法通过类成员指针调用了存储的类成员函数指针，同样使用了 forward 转发参数。

​ 这样，通过继承自 BASE 并在派生类中实现 run 方法，你的 function 类就能够包装不同类型的函数指针了。

​ 在 function 类中，构造函数根据传入的参数类型选择相应的类来实例化，从而实现了对普通函数和类成员函数的封装。operator() 方法最终调用了 run 方法，使得你可以通过 function 对象调用包装的函数。

​ 需要注意的是，代码中使用了 forward<ARGS>(args)... 来转发参数，这是为了保留参数的完美转发性质，即传递参数时保留其值类别（lvalue 或 rvalue）和 const 限定符。

实现f1 = f2;赋值操作

template<typename T, typename ...ARGS>
class BASE {
public:
    virtual T run(ARGS...) = 0;
    virtual BASE *getCopy() = 0;
};

template<typename T, typename ...ARGS>
class normal_function : public BASE<T, ARGS...> {
public:
    normal_function(T (*ptr)(ARGS...)) : ptr(ptr) {}
    T run(ARGS... args) override {
        return ptr(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        BASE<T, ARGS...> *fun = new normal_function(ptr);
        return fun;
    }

private:
    T (*ptr)(ARGS...);
};

template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:
    B(U *u) : u(u), ptr(&U::operator()) {}
    T run(ARGS... args) override {
        return (u->*ptr)(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        BASE<T, ARGS...> *fun = new B(u);
        return fun;
    }

private:
    U *u;
    T (U::*ptr)(ARGS...);
};

template<typename T, typename ...ARGS> class function {};
template<typename T, typename ...ARGS>
class function<T(ARGS...)> {
public:
    function(T (*ptr)(ARGS...)) : ptr(new normal_function<T, ARGS...>(ptr)) {}
    template<typename U>
    function(U &u) : ptr(new B<U, T, ARGS...>(&u)) {}
    T operator()(ARGS... args) {
        return ptr->run(args...);
    }
    function &operator=(const function &fun) {
        delete ptr;
        this->ptr = fun.ptr->getCopy();
        return *this;
    }
    ~function() {
        delete ptr;
    }

private:
    BASE<T, ARGS...> *ptr;
};

  • 赋值操作符首先删除当前对象 (this) 的 ptr 指针指向的对象

  • 然后通过调用 fun.ptr->getCopy() 来获取 fun 对象的一个副本，并将其赋值给当前对象的 ptr

  • 这里 getCopy 方法是一个虚函数，它在基类 BASE 中声明并在派生类中实现。在派生类中，getCopy 的实现会创建一个新的对象，该对象的类型是当前派生类，然后返回这个新对象的指针。

  • 赋值操作符实际上是在进行深拷贝，确保两个 function 对象之间不共享相同的函数对象。这里使用了虚函数 getCopy 来创建副本，而不是简单的指针复制。这可以防止在两个 function 对象中的 ptr 指针指向相同的内存位置，从而避免在一个对象的析构时影响另一个对象。

这是我们就基本完成了function模板函数的基本功能。

完整代码：

/*************************************************************************
        > File Name: test.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Thu Nov 16 19:37:14 2023
 ************************************************************************/

#include <iostream>

using namespace std;

template<typename T, typename ...ARGS>
class BASE {
public:
    virtual T run(ARGS...) = 0;
    virtual BASE *getCopy() = 0;
};

template<typename T, typename ...ARGS>
class normal_function : public BASE<T, ARGS...> {
public:
    normal_function(T (*ptr)(ARGS...)) : ptr(ptr) {}
    T run(ARGS... args) override {
        return ptr(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        BASE<T, ARGS...> *fun = new normal_function(ptr);
        return fun;
    }

private:
    T (*ptr)(ARGS...);
};

template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:
    B(U *u) : u(u), ptr(&U::operator()) {}
    T run(ARGS... args) override {
        return (u->*ptr)(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        BASE<T, ARGS...> *fun = new B(u);
        return fun;
    }

private:
    U *u;
    T (U::*ptr)(ARGS...);
};

template<typename T, typename ...ARGS> class function {};
template<typename T, typename ...ARGS>
class function<T(ARGS...)> {
public:
    function(T (*ptr)(ARGS...)) : ptr(new normal_function<T, ARGS...>(ptr)) {}
    template<typename U>
    function(U &u) : ptr(new B<U, T, ARGS...>(&u)) {}
    T operator()(ARGS... args) {
        return ptr->run(args...);
    }
    function &operator=(const function &fun) {
        delete ptr;
        this->ptr = fun.ptr->getCopy();
        return *this;
    }
    ~function() {
        delete ptr;
    }

private:
    BASE<T, ARGS...> *ptr;
};

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

class ADD_MULT {
public:
    ADD_MULT(int x) : x(x) {}
    int operator() (int a, int b) {
        return (a + b + x) * 2;
    }
    int x;
};

int main() {
    ADD_MULT add_mult(2);
    function<int(int, int)> f1 = add;
    function<int(int, int)> f2 = add_mult;
    cout << f1(3, 4) << endl;
    cout << f2(3, 4) << endl;
    f1 = f2;
    cout << f1(3, 4) << endl;
    f1 = add;
    f2 = add_mult;
    cout << f1(3, 4) << endl;
    cout << f2(3, 4) << endl;
    return 0;
}

优化：

/*************************************************************************
        > File Name: test.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Thu Nov 16 19:37:14 2023
 ************************************************************************/

#include <iostream>
#include <functional>

using namespace std;

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

class ADD_MULT {
public:
    ADD_MULT(int x) : x(x) {}
    int operator() (int a, int b) {
        return (a + b + x) * 2;
    }
    int x;
};

int main() {
    ADD_MULT add_mult(2);
    function<int(int, int)> f1 = add_mult;
    cout << f1(2, 3) << endl;
    add_mult.x = 10;
    cout << f1(2, 3) << endl;
    return 0;
}

我们在这里试着调用functional中的function模板函数，这里我们试着更改add_mult.x = 10;这个的值，然后再次输出：我们输出一下，看看结果：

在这里插入图片描述

可以发现值并没有发生变化，而我们用我们实现的代码来运行一下这段代码：

在这里插入图片描述

可以发现是会变化的，因为我们上面用的是指针来实现的，我们来进行修改（虽然我认为按照我的思路来说，修改了才是对的）：

/*************************************************************************
        > File Name: test1.cpp
        > Author:Xiao Yuheng
        > Mail:3312638794@qq.com
        > Created Time: Thu Nov 16 20:02:50 2023
 ************************************************************************/

#include <iostream>

using namespace std;

template<typename T, typename ...ARGS>
class BASE {
public:
    virtual T run(ARGS...) = 0;
    virtual BASE *getCopy() = 0;
};

template<typename T, typename ...ARGS>
class normal_function : public BASE<T, ARGS...> {
public:
    normal_function(T (*ptr)(ARGS...)) : ptr(ptr) {}
    T run(ARGS... args) override {
        return ptr(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        BASE<T, ARGS...> *fun = new normal_function(ptr);
        return fun;
    }

private:
    T (*ptr)(ARGS...);
};

/*
template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:
    B(U *u) : u(u), ptr(&U::operator()) {}
    T run(ARGS... args) override {
        return (u->*ptr)(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        BASE<T, ARGS...> *fun = new B(u);
        return fun;
    }

private:
    U *u;
    T (U::*ptr)(ARGS...);
};
*/

template<typename U, typename T, typename ...ARGS>
class B : public BASE<T, ARGS...> {
public:
    B(U u) : u(u) {}
    T run(ARGS... args) override {
        return u(forward<ARGS>(args)...);
    }
    BASE<T, ARGS...> *getCopy() override {
        return new B(u);
    }

private:
    U u;
};

template<typename T, typename ...ARGS> class function {};
template<typename T, typename ...ARGS>
class function<T(ARGS...)> {
public:
    function(T (*ptr)(ARGS...)) : ptr(new normal_function<T, ARGS...>(ptr)) {}
    template<typename U>
    function(U &u) : ptr(new B<U, T, ARGS...>(u)) {}
    T operator()(ARGS... args) {
        return ptr->run(args...);
    }
    function &operator=(const function &fun) {
        delete ptr;
        // this->ptr = fun.ptr;
        this->ptr = fun.ptr->getCopy();
        return *this;
    }
    ~function() {
        delete ptr;
    }

private:
    BASE<T, ARGS...> *ptr;
};



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

class ADD_MULT {
public:
    ADD_MULT(int x) : x(x) {}
    int operator() (int a, int b) {
        return (a + b) * 2;
    }
    int x;
};

int main() {
    ADD_MULT add_mult(2);
    function<int(int, int)> f1 = add;
    function<int(int, int)> f2 = add_mult;
    cout << f1(3, 4) << endl;
    cout << f2(3, 4) << endl;
    f1 = f2;
    cout << f1(3, 4) << endl;
    f1 = add;
    f2 = add_mult;
    cout << f1(3, 4) << endl;
    cout << f2(3, 4) << endl;
    return 0;
}

​ 我们这里的B类的构造函数之间用一个B类的对象来继续接收就欧克了。

拾雪藏于春
关注
  • 23
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 手写一个线程池
余识-
07-08 1591
本章要介绍的是线程的进阶版本：线程池。如果你使用过线程，就会知道，每当你想要启用一个任务时，就必须手动去启动一个线程来执行指定的任务。这是很自然的想法，并且也并没有什么不对。当问题就出在，电脑CPU可以同时执行的线程数量并不是无限多的，比如我目前电脑CPU是4核8线程的，意思就是同时最多也只能执行8个线程。如果超过了这个数量，那么CPU就需要不断切换线程，调动资源，让其它线程也能进来运行一会。这个过程相当损耗性能。为了解决这个问题，就有了线程池的概念。
手写matlab中滤波函数的代码,matlab中滤波器函数 求MATLAB中filter2函数的源代码。...
weixin_29107819的博客
03-17 850
matlab中滤波器函数 求MATLAB中filter2函数的源代码。????求MATLAB中二维滤波函数filter2的编码程序。。。 急急~ 若需要函数体，我可以传文件给你。下面是其代码 function y = filter2(b,x,shape)%FILTER2 Two-dimensional digital filter.% Y = FILTER2(B,X) filters the dat...
C++11 std::function 基础用法
Bobowen的博客
01-15 6491
std::function是C++11标准库中提供的一种可调用对象的通用类型，它可以存储任意可调用对象，如函数指针，函数对象，成员函数指针和lambda表达式。std::function类模板是一个类似于函数指针的类型，但它是可以处理任意可调用对象的，并且可以检查调用对象是否为空。
C++可调用对象与function
Stay hungry, Stay foolish
01-16 427
C++语言有几种可调用对象：函数、函数指针、lambda表达式、bind创建的对象以及重载了函数调用运算符的类。 和其他对象一样，可调用的对象也有类类型。例如，每个lambda有它自己唯一的（未命名）类类型；函数及函数指针的类型则由其返回值类型和实参类型决定。 然而，两种不同类型的可调用对象却可能共享同一种调用形式。调用形式指明了调用返回的类型以及传递给调用的实参类型。一种调用形式对应一个函数类型，例如： int(int, int); 是一个函数类型，它接受两个int,返回一个int 不同类
手写js函数
yuMingXia_7的博客
05-24 482
1.call的实现 第一个参数为null或者undefined时，this指向全局对象window，值为原始值的指向该原始值的自动包装对象，如 String、Number、Boolean 为了避免函数名与上下文(context)的属性发生冲突，使用Symbol类型作为唯一值 将函数作为传入的上下文(context)属性执行 函数执行完成后删除该属性 返回执行结果 Function.prototype.myCall=function(context,....
torch.autograd.Function的使用
Bobby's Blog
04-11 701
（个人理解仅供参考）
手写一个Webpack吧~
量子前端的博客
07-02 839
手写一个简易版的webpack，将所有模板整合到bundle.js中
手写一个vue2的diff案例
weixin_47818125的博客
05-31 907
在某些情况下，如果同一组件在不同的渲染中，存在相同的 key，Vue 可能会复用该组件的状态。总体来说，Vue.js 2.x 中的 Virtual DOM diff 算法主要通过创建新旧虚拟 DOM 树的比较，并根据差异进行最小化的更新来实现高效的页面更新。而当列表中的元素有 key 时，Vue 会基于 key 的变化重新排序和更新元素，这样可以确保列表的变化能够正确地映射到数据的变化上，避免出现意外的渲染结果。差异的应用：最后，Vue.js 根据这些差异使用最小的操作数来更新真实 DOM。
一步步手撸一个std::function
老宅的虚拟空间
01-16 981
纸上得来终觉浅，绝知此事要躬行！ 我们分析过std::function的实现原理，但这只是纸上谈兵。要想理解为什么这么实现，最好的办法还是想想要是自己手写一个要怎么实现。本文不想直接呈现最终版本，因为那样读者看不到某段代码是为了什么才那么写。我会搭建好几版，争取把所想所思都体现出来。
js代码-手写节流函数
07-16
本文将深入探讨如何手写一个JavaScript节流函数，以及其背后的原理。 节流函数的基本思想是设置一个时间间隔，在这个间隔内，无论函数被调用多少次，都只执行一次。当这个时间间隔过去后，如果函数再次被调用，它又...
js代码-手写防抖函数
07-16
我们可以创建一个基础的防抖函数模板，接受一个待执行的函数`fn`和延迟时间`delay`作为参数： ```javascript function debounce(fn, delay) { let timeoutId; return function() { const context = this; // ...
概率神经网络在手写汉字识别中的应用.pdf
09-26
手写汉字识别是计算机视觉和模式识别领域的一个重要课题，尤其是在数字化文档处理、智能输入设备以及移动通信等领域有着广泛的应用。传统的识别方法，如基于模板匹配和结构分析的方法，由于其对书写风格的依赖性和...
十大支持向量机最强总结！！.docx
06-21
- **核心原理**：通过非线性映射将原始数据映射到一个更高维的空间，在这个空间内寻找一个最优超平面来进行分类。 - **决策函数**：非线性SVM的决策函数可以表示为： \[ f(x) = \text{sign}\left(\sum_{i=1}^{n}\...
基于支持向量SVM的手写体数字识别（代码完整，数据齐全）
08-14
本文将详细讲解基于支持向量机（Support Vector Machine, SVM）的手写体数字识别技术，以及如何使用MATLAB实现这一过程。首先，我们要理解SVM的基本原理：它是一种监督学习模型，通过找到最大边距超平面来实现分类，...
Flink开发语言使用Java还是Scala合适？
08-06 1246
在大数据处理和实时流处理的领域，Apache Flink已经成为了一款备受瞩目的工具。Flink提供了强大的分布式计算能力，能够处理海量数据并支持复杂的流处理操作。然而，对于开发者来说，选择合适的编程语言是使用Flink进行开发的重要决策。目前，Java和Scala是Flink最常用的两种开发语言。本文将深入探讨在Flink开发中使用Java和Scala的各自优势和劣势，并通过实例代码展示两者在实际开发中的应用，以帮助读者做出更明智的选择。
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 206
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 196
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 325
STL中的迭代器失效（vector为例）
手写一个拉普拉斯滤波，matlab
07-10
下面是一个简单的 MATLAB 代码示例，用于实现拉普拉斯滤波： ```matlab function output_image = laplacian_filter(input_image) % 定义拉普拉斯滤波模板 laplacian_template = [0 -1 0; -1 4 -1; 0 -1 0]; % ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值