跟我学c++中级篇——类型擦除的应用

最新推荐文章于 2024-08-21 06:34:43 发布
最新推荐文章于 2024-08-21 06:34:43 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： C++11 架构设计 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fpcc/article/details/128506203
版权

一、类型擦除的效果

前面分析了类型擦除，通过分析可以知道。类型擦除其实就是一种抽象，不通过继承来实现动态行为，从而更好的实现可扩展性和耦合性。在设计程序时，大家都知道，要依赖于抽象而不是具体。由于类型的限制，在c++这种强类型语言中，往往会造成抽象的复杂性，甚至在某些情况下是无法达到抽象的结果的。
特别在模板编程中，这种现象往往更是突出，所以类型擦除在这方面有着很大的施展空间。

二、例程及分析

在这里首先分析一个线程任务的队列控制例程，通过这个例程可以更好的明白类型擦除的用处。一般来说，任务就是一个函数，或者可以理解成一个实现函数功能的对象。通过前面的学习，就可以知道了，主要有三大类，普通函数（含函数指针）、仿函数和lambda表达式。在摒除一些细节后，如何把这三类统一起来就是一种抽象。在早期的开发中，一般都是只考虑一类，大多都是使用函数指针，在c++11推出以后，更多的开发者开始使用std::function，因为它把三类也给统一了。下面看一个简单的例程，形象的理解一下：

#include <iostream>
#include <memory>
#include <queue>

//基础应用
typedef void(*pFtask)();
void WorkTask()
{
    std::cout << "do work" << std::endl;
}
class BaseTask
{
public:
    BaseTask() = default;
    virtual ~BaseTask() = default;
public:
    virtual void DoWork() const = 0;
};
class TaskImpl :public BaseTask
{
public:
    TaskImpl() = default;
    ~TaskImpl() = default;
public:
    void DoWork()const override
    {
        WorkTask();
    }
};
class ThreadWork
{
public:
    ThreadWork() = default;
    ~ThreadWork() = default;
public:
public:
    std::queue<std::unique_ptr<BaseTask>> qTask_;
};
int main()
{
    //make_unique是c++14才提供，这里暂时用主线程来模拟线程
    std::unique_ptr<BaseTask> pTask = std::make_unique<TaskImpl>();
    ThreadWork tw;
    tw.qTask_.emplace(std::move(pTask));

    //仍然使用主线程模拟任务执行
    auto pT = std::move(tw.qTask_.front());
    tw.qTask_.pop();

    pT->DoWork();
    system("pause");
}

下面就从上面这个最初的代码一步步的扩展开去，看看类型擦除在这上面是如何应用的。上面的代码其实对于一些内部使用的线程操作基本没有什么问题了，再完善一下队列，增加一个内存池，这就是一个基本可用的线程池的整体模型。
但是这样有一些问题，第一，每次实现不同的任务或者不同的开发者实现自己的任务都需要继承基础的抽象类，这里先不谈效率，时间长后，对维护本身就非常不友好；第二，使用者无法屏蔽对代码的抽象，仍然需要了解代码，即使这个代码很简单，同样这种抽象也限制了任务的扩展。
另外，如果想使用仿函数和lambda表达式，又该怎么样？能不能有一种情况，让客户拿来任务数据结构直接就使用，只实现任务函数即类似于下面的这样：

//定义
class WorkTask
{
public:
   //函数对象管理
   template <typename F>
   WorkTask(F&& f):f_(std::move(f));
public:
    void operator()()const;
private:
    F f_;
};

//使用
WorkTask wTask{/*用户自定义的任务执行函数对象，要支持函数指针、lambda表达式和仿函数*/};
wTask();

如果这样使用，对应用用户就友好了很多，编程的维护复杂性也大大降低。怎么实现这个呢？先看一下代码：

class BaseTask
{
public:
    BaseTask() = default;
    virtual ~BaseTask() = default;
public:
    virtual void DoWork() const = 0;
    virtual void operator()()const = 0;
};
template<typename F>
class TaskImpl :public BaseTask
{
public:
    TaskImpl() = default;
    template<typename T>
    TaskImpl(T&& t) :func_(std::forward<T>(t)) {}
    ~TaskImpl() = default;
public:
    void DoWork()const override
    {
        //WorkTask();
        std::cout << "start task!" << std::endl;
    }
    void operator()()const override
    {
        func_();
    }

public:
    F func_;
};

在上面的代码中，首先增加了对小括号的重载，重载的目的当然就是对仿函数的支持。在前面的“类型擦除”分析中，可以知道，函数指针和受约束的模板构造函数是实现类型擦除的关键。从上面的代码看，抛除对约束的控制，函数指针（包含仿函数）就是首要（func_），基本的任务体TaskImpl采用了模板类和模板构造函数。好多技术在学习的过程中，往往是只重点对某一方向进行分析，但较少的是前后响应，互相借鉴，这并不是说写文章的人水平不够，而是说很多写文章的人往往忽视了这一点，陷入了技术细节的分析和描述。而这也往往是很多人学会一个单独的技巧或者技术后不能够应用于实际场景的一个非常重要的原因。扯远了，再扯回来。
上面的代码解决了类型擦除的基本问题，也印证了前面说的如何实现类型擦除的手段。但是这样用，仍然有一些暴露细节，所以需要再封装一层：

class TaskWrapper
{
public:
    TaskWrapper() = default;
    template<typename F>
    TaskWrapper(F &&f)
    {
        using standType =  TaskImpl<F>;
        pTask_ = std::make_unique<standType>(std::forward<F>(f));
    }
    ~TaskWrapper() = default;
public:
    void operator()()const 
    {
        pTask_->operator()();
        //pTask_->DoWork();
    }
public:
    std::unique_ptr<BaseTask> pTask_;
};

通过对基本任务类的封装，并且进行仿函数的operator重载，这样，就可以将三类函数对象的支持统一到此类中。对其进行测试：

void WorkTask()
{
    std::cout << "do work,type erase" << std::endl;
}

class WorkTaskFunc
{
public:
    void operator()()const 
    {
        std::cout << "functor  ,type erase" << std::endl;
    }
};

auto tasklambda = []() {std::cout << "lambda,type erase" << std::endl; };
int main()
{
    //分三种情况
    //普通函数
    TaskWrapper tw1{ WorkTask };
    tw1();

    //仿函数
    TaskWrapper tw2{ WorkTaskFunc{} };
    tw2();

    //Lambda表达式
    TaskWrapper tw3{ tasklambda };
    tw3();

    return 0;
}

然后再象开始一样把代码集成到ThreadWork中：

void TestTask()
{
    //分三种情况
    //普通函数
    TaskWrapper tw1{ WorkTask };
    tw1();

    //仿函数
    TaskWrapper tw2{ WorkTaskFunc{} };
    tw2();

    //Lambda表达式
    TaskWrapper tw3{ tasklambda };
    tw3();

    ThreadWork tWork;
    tWork.qW_.emplace(std::move(tw1));
    tWork.qW_.emplace(std::move(tw2));
    tWork.qW_.emplace(std::move(tw3));

    auto t1 = std::move(tWork.qW_.front());
    tWork.qW_.pop();

    auto t2 = std::move(tWork.qW_.front());
    tWork.qW_.pop();

    auto t3 = std::move(tWork.qW_.front());
    tWork.qW_.pop();

    t1();
    t2();
    t3();
}

程序一运行就崩溃了，报得错误是在执行t1()时，资源被释放，TaskWrapper中的pTask_已经被释放。原来此处用的是std::unique_ptr，它只能移动不能拷贝，于是就得对移动构造函数和移动复制函数进行显示声明，同时处理掉复制相关的函数：

class TaskWrapper
{
......
public:
    TaskWrapper(TaskWrapper&& other)noexcept :pTask_(std::move(other.pTask_)) {}
    TaskWrapper& operator = (TaskWrapper&& rhs)noexcept
    {
        pTask_ = std::move(rhs.pTask_);
        return *this;
    }
    //处理复制构造、赋值函数
    TaskWrapper(const TaskWrapper&) = delete;
    TaskWrapper& operator=(const TaskWrapper&) = delete;
......
};

最后再统一到队列中,看完整的代码：

#include <iostream>
#include <memory>
#include <utility>
#include <queue>

//基础应用
typedef void(*pFtask)();
//普通函数
void WorkTask()
{
    std::cout << "do work,type erase" << std::endl;
}
//仿函数
class WorkTaskFunc
{
public:
    void operator()()const 
    {
        std::cout << "functor  ,type erase" << std::endl;
    }
};
//lambda表达式
auto tasklambda = []() {std::cout << "lambda,type erase" << std::endl; };

//任务基础抽象类
class BaseTask
{
public:
    BaseTask() = default;
    virtual ~BaseTask() = default;
public:
    virtual void DoWork() const = 0;
    virtual void operator()()const = 0;
};
//标准任务类
template<typename F>
class TaskImpl :public BaseTask
{
public:
    TaskImpl() = default;
    template<typename T>
    TaskImpl(T&& t) :func_(std::forward<T>(t)) {}
    ~TaskImpl() = default;
public:
    void DoWork()const override
    {
        //WorkTask();
        std::cout << "start task!" << std::endl;
    }
    void operator()()const override
    {
        func_();
    }

public:
    F func_;
};
//任务封装打包器
class TaskWrapper
{
public:
    TaskWrapper() = default;
    template<typename F>
    TaskWrapper(F &&f)
    {
        using standType =  TaskImpl<F>;
        //typedef     TaskImpl<F>  standType;
        pTask_ = std::make_unique<standType>(std::forward<F>(f));
    }
    ~TaskWrapper() = default;
public:
    TaskWrapper(TaskWrapper&& other)noexcept :pTask_(std::move(other.pTask_)) {}
    TaskWrapper& operator = (TaskWrapper&& rhs)noexcept
    {
        pTask_ = std::move(rhs.pTask_);
        return *this;
    }
    TaskWrapper(const TaskWrapper&) = delete;
    TaskWrapper& operator=(const TaskWrapper&) = delete;
public:
    void operator()()const 
    {
        pTask_->operator()();
        //pTask_->DoWork();
    }
public:
    std::unique_ptr<BaseTask> pTask_;
};
//线程任务管理类
class ThreadWork
{
public:
    ThreadWork() = default;
    ~ThreadWork() = default;
public:
public:
    std::queue<std::unique_ptr<BaseTask>> qTask_;
    std::queue<TaskWrapper> qW_;
    //std::queue<std::unique_ptr<TaskWrapper>> qpW_;
};

void TestTask()
{
    //分三种情况
    //普通函数
    TaskWrapper tw1{ WorkTask };
    tw1();

    //仿函数
    TaskWrapper tw2{ WorkTaskFunc{} };
    tw2();

    //Lambda表达式
    TaskWrapper tw3{ tasklambda };
    tw3();

    ThreadWork tWork;
    tWork.qW_.emplace(std::move(tw1));
    tWork.qW_.emplace(std::move(tw2));
    tWork.qW_.emplace(std::move(tw3));

    auto t1 = std::move(tWork.qW_.front());
    tWork.qW_.pop();

    auto t2 = std::move(tWork.qW_.front());
    tWork.qW_.pop();

    auto t3 = std::move(tWork.qW_.front());
    tWork.qW_.pop();

    t1();
    t2();
    t3();

}
int main()
{
    TestTask();
    system("pause");

    return 0;
}

这个至简的框架Demo，只是一个基本的描述，到一个真正的工程模块，还有遥远的距离，但是从思想上掌握了这种开发的方式，就能够更好的指导着代码的设计和开发，这才是学习别人借鉴别人的经验的意义。学以致用，这才是最重要的。
在上面如果队列使用智能指针，或者在打包类中等使用std::shared_ptr，就可以不进行移动复制等函数的控制，但那样做的话，前者应用起来不是特别友好，不符合开发者的习惯；后者在多线程中就可能产生对象的控制的同步复杂性。

三、总结

从很早就从网上书上看到很多牛人写这个任务队列，自己也曾经反复尝试写过类似的多线程队列操作，都非常不满意。即使到现在觉得这个东西仍然有很大的完善和修改空间，有机会还是要在实际场景中对此类型的需求进行一次整体的重构。希望还能找到这个机会。

fpcc
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 8万+
C/C++学习路线总结与分享
C++ 应用软件开发从入门到精通详解
热门推荐
dvlinker的技术专栏
06-21 2万+
本文详细介绍一下Windows平台下用C++开发应用软件的诸多内容，以供大家借鉴或参考。
AnySet:用C ++ 17编写的类型擦除的哈希集
05-18
AnySet AnySet是采用C ++ 17编写的std::unordered_set样式的类型擦除的哈希集。 简而言之，您可以执行以下整洁的工作： using namespace std ::literals ; te::AnySet<> set ({ " Add " s, " a " s, " few " s, " strings " s}); // Or add some ints set.insert({ 1 , 2 , 3 , 4 }); // Or just whatever set.insert( " Hello " s, 1 , 3.1415 , std::bitset< 3>{ 0b011u }); // .contains() ... assert (set.contains( " Hello " s)); // With the appropriate
C++中的类型擦除（type erasure in c++）
weixin_30444105的博客
12-10 396
作者：唐风出处：http://www.cnblogs.com/liyiwen本文版权归作者和博客园共有，欢迎转载，但请保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 关于类型擦除，在网上搜出来的中文资料比较少，而且一提到类型擦除，检索结果里就跑出很多 Java 和 C# 相关的文章来（它们实现“泛型”的方式）。所以，这一篇我打算写得稍微详细一点。 注意，这是...
跟我学c++中级篇——类型擦除
fpcc的专栏
12-01 2089
对c++的类型擦除进行分析说明
C++ 类型擦除
tuan8888888的博客
03-24 1183
为什么要类型擦除 在使用容器的时候，std::vector<int> ,存储的类似是int，我们都支持vector是一个模板类，可以支持不同的类型。但是如果一个vector只能支持一种类型。 但是有一个需求需要在一个容器内存储不同的类型，例如：int , double 那容器肯定是没有办法支持的。 如何解决： 那只有一个办法将int 和 double 转换成一个类型，例如这个类型就叫做Any。这个Any类型可以在转换int，和double 。此时我们vector就可以存储所有的类型.
（原创）c++中的类型擦除
weixin_33762321的博客
08-13 223
c++11 boost技术交流群：296561497，欢迎大家来交流技术。 关于类型擦除，可能很多人都不清楚，不知道类型擦除是干啥的，为什么需要类型擦除。有必要做个说明，类型擦除就是将原有类型消除或者隐藏。为什么要擦除类型？因为很多时候我不关心具体类型是什么或者根本就不需要这个类型，通过类型擦除我们可以获取很多好处，比如使得我们的程序有更好的扩展性、还能消除耦合以及消除一些重复行为，使程序更加简...
C++中的类型擦除
天秤座的唐风
04-04 1546
关于类型擦除，在网上搜出来的中文资料比较少，而且一提到类型擦除，检索结果里就跑出很多 Java 和 C# 相关的文章来（它们实现“泛型”的方式）。所以，这一篇我打算写得稍微详细一点。 注意，这是一篇读书笔记（《C++ template metaprogramming》第9.7小节和《C++ テンプレートテクニック》第七章），里面的例子都来自原书。 在 C++ 中，编译器在编译期进行的静态类
C++学习——数据类型（强制）转换详解
流楚丶格念的博客
04-03 6800
有时，编程的过程中需要将值从一种数据类型转换为另一种数据类型。C++ 提供了这样做的方法。 如果将一个浮点值分配给一个 int 整型变量，该变量会接收什么值？如果一个 int 整数乘以一个 float 浮点数，结果将会是什么数据类型？如果一个 double 浮点数除以一个 unsigned int 无符号整数会怎么样？是否有办法预测在这些情况下会发生什么？ 答案是肯定的。当运算符的操作数具有不同的...
数据结构C++语言描述——应用标准模板库 第2版
01-11
数据结构C++语言描述——应用标准模板库
详解C++值多态中的传统多态与类型擦除
08-19
值多态是一种介于传统多态与类型擦除之间的多态实现方式，借鉴了值语义，保留了继承，在单继承的适用范围内，程序和程序员都能从中受益。这篇文章主要介绍了C++值多态中的传统多态与类型擦除,需要的朋友可以参考下
数据结构C++语言描述——应用标准模板库STL
11-05
数据结构C++语言描述——应用标准模板库STL.PDF
C++多态的另一种实现：类型擦除
QQ哥的专栏
12-01 1034
C++多态的另一种实现：类型擦除
理解 C++ 中的类型擦除（Type Erasure）
最新发布
windowshht的博客
08-21 824
类型擦除是一种编程技术，它允许我们在不暴露具体类型的情况下，使用不同的类型。这意味着我们可以在运行时处理不同类型的对象，而不需要在编译时知道这些类型。类型擦除的主要目的是提供一种灵活的方式来处理多态性，尤其是在泛型编程中。类型擦除是一种强大的技术，它允许我们在 C++ 中以灵活的方式处理不同类型的对象。通过使用基类指针、和类型擦除类，我们可以实现多态性和泛型编程的目标。在实际开发中，合理使用类型擦除可以提高代码的灵活性和可维护性，但也需要注意性能开销和类型安全性的问题。
C++中的类型擦除技术
喜欢打篮球的普通人
08-17 1397
在 main() 函数中，我们创建了两个不同类型的 Derived 对象 d1 和 d2，然后创建了一个 Functor 对象 f。通过调用 f(d1) 和 f(d2)，我们将不同类型的对象传递给函数对象 f，它将根据对象的类型调用适当的 foo() 实现。process() 函数接受一个 std::function 类型的参数，它表示一个无返回值、不带参数的可调用对象。C++语境下的类型擦除，技术上来说，是编写一个类，它提供模板的构造函数和非虚函数接口提供功能；所以，这段代码可以过编译。
c++学习笔记(3)-类型擦除
沸腾了的博客
12-26 611
C++ 类型擦除是指通过一些技术手段去掉（或“擦除”）C++ 中的类型信息，使得一个数据结构或算法能够处理不同类型的对象。类型擦除可以使得泛型编程变得更加灵活和通用，可以将相同的算法应用于不同类型的数据上，而无需对算法进行修改。在C++中，有两种主要的类型擦除方法，分别是基于模板类的类型擦除和基于虚函数的类型擦除。
C++: 类型擦除（type erasure）
Peace
10-23 1492
在 C++ 中，编译器在编译期进行的静态类型检查是比较严格的，但有时候我们却希望能“避过”这样的类型检查，以实现更灵活的功能，同时又尽量地保持类型安全。听起来很矛盾，而且貌似很难办到。但其实 C++ 的库里已经有很多这样的应用了。比如，著名的 boost::function 和 boost::any 。当我们定义一个 function<void(int)> fun 对象，则 fun 即可以存储函数指针，又可以存储函数对象，注意，这两者是不同“类型”的，而且函数对象可以是无限种类型的...
C++的类型擦除记录
qq18218628646的博客
08-18 78
C++ 类型擦除是指通过一些技术手段去掉（或“擦除”）C++ 中的类型信息，使得一个数据结构或算法能够处理不同类型的对象。类型擦除可以使得泛型编程变得更加灵活和通用，可以将相同的算法应用于不同类型的数据上，而无需对算法进行修改。在C++中，有两种主要的类型擦除方法，分别是基于模板类的类型擦除和基于虚函数的类型擦除。基于模板类的类型擦除：这种类型擦除方法主要是通过定义通用的模板类来实现。标准模板库中的容器类（如vector、list等）就是基于模板类的类型擦除实现的。
c++模板编程- 函数对象的简单实现(类型擦除)
qq_34179431的博客
10-19 272
template<typename R, typename... Args> class FunctorBridge { public: virtual ~FunctorBridge() = default; virtual FunctorBridge *clone() const = 0; virtual R invoke(Args... args) = 0; virtual R invoke(Args... args) const = 0; };
C++值多态：传统多态与类型擦除的实战应用
本文将深入探讨C++中的值多态，特别是其与传统多态和类型擦除的区别与联系。值多态是一种在单继承场景下，结合了值语义和多态性的编程技术，它允许程序员在不使用指针或引用的情况下，以统一的方式处理不同类型的...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值