对象池学习——lambd表达式，完美转发，共享指针

最新推荐文章于 2024-05-18 17:40:35 发布
最新推荐文章于 2024-05-18 17:40:35 发布
阅读量114 收藏
点赞数
分类专栏： c++ 对象池 文章标签： 学习 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54419195/article/details/131847026
版权

lambd表达式

在这里插入图片描述

    1.捕获列表。在C++规范中也称为Lambda导入器， 捕获列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数，捕获列表能够捕捉上下文中的变量以供Lambda函数使用。
    2.参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号“()”一起省略。
    3.可变规格。mutable修饰符， 默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
    4. 异常说明。用于Lamdba表达式内部函数抛出异常。
    5. 返回类型。 追踪返回类型形式声明函数的返回类型。我们可以在不需要返回值的时候也可以连同符号”->”一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
    lambda函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

捕获列表

[]表示不捕获任何变量
[var]表示值传递方式捕获变量var
[=]表示值传递方式捕获所有父作用域的变量（包括this）
[&var]表示引用传递捕捉变量var
[&]表示引用传递方式捕捉所有父作用域的变量（包括this）
[this]表示值传递方式捕捉当前的this指针
[=, &] 拷贝与引用混合

[=, &a, &b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量
[&, a, this]表示以值传递的方式捕捉变量a和this，引用传递方式捕捉其它所有变量。

不过值得注意的是，捕捉列表不允许变量重复传递。下面一些例子就是典型的重复，会导致编译时期的错误。例如：

[=,a]这里已经以值传递方式捕捉了所有变量，但是重复捕捉a了，会报错的；
[&,&this]这里&已经以引用传递方式捕捉了所有变量，再捕捉this也是一种重复。

第一代对象池


#ifndef OBJECTPOOL1_HPP
#define OBJECTPOOL1_HPP

#include<list>
#include<memory>
#include<iostream>
using namespace std;

template<class TObject>
class ObjectPool
{
private:
    std::list<TObject *> idlepool;
public:
    ObjectPool() {}
    ~ObjectPool()
    {
        clear();
    }
    ObjectPool(const ObjectPool &) = delete; //C++11
    ObjectPool & operator=(const ObjectPool &) = delete;
public:
    std::shared_ptr<TObject> acquire()
    {
        if(idlepool.empty())
        {
            return std::shared_ptr<TObject> (new TObject(),
                                             [&](TObject *p)->void
                                             {
                                                idlepool.push_back(p);
                                             });
//共享指针管理new TObject()，在引用计数等于0调用删除器的时候，
//new TObject()就会把自己的地址给删除器，也就是p指向了这个new TObject()
        }
        else
        {
            auto ptr = idlepool.front();
            idlepool.pop_front();
            return std::shared_ptr<TObject> (ptr,
                                            [&](TObject *p)->void 
                                            { 
                                                idlepool.push_back(p);
                                            });

        }
    }
    size_t getsize() const
    {
        return idlepool.size();
    }
    void clear()
    {
       for(auto &pobj : idlepool)
       {
            delete pobj;
            pobj = nullptr;
       } 
       idlepool.clear();
    }
};
//这里结构是队列，有前驱域，后继域，数据域，其中数据域指向智能指针的地址，
//所以在删除的时候先删除智能指针并置空，再讲队列这个数据结构删掉

#endif

第二代对象池（添加了完美转发和可变模板参数）

#ifndef OBJECTPOOL2_HPP
#define OBJECTPOOL2_HPP

#include <list>
#include <memory>
#include <iostream>
using namespace std;

template <class TObject>
class ObjectPool
{
private:
    std::list<TObject *> idlepool;

public:
    ObjectPool() {}
    ~ObjectPool()
    {
        clear();
    }
    ObjectPool(const ObjectPool &) = delete; // C++11
    ObjectPool &operator=(const ObjectPool &) = delete;

public:
//是C++中的可变参数模板的语法表示。
//在C++11之后，引入了可变参数模板的特性，使得可以定义接受任意数量、任意类型的模板参数的函数或类模板。
    template <class... Args>
    std::shared_ptr<TObject> acquire(Args &&...args)
    //Args：是模板参数包的名称，表示函数接受的模板参数的类型。
//&&：是右值引用的标记，用于实现完美转发的功能。
//通过使用&&，acquire函数可以在保留传入参数的引用性质的同时，将其转发给其他函数。
    {
        if (idlepool.empty())
        {
            return std::shared_ptr<TObject>(
                new TObject(std::forward<Args>(args)...),
                [&](TObject *p) -> void
                {
                    idlepool.push_back(p);
                });
        }
        else
        {
            auto ptr = idlepool.front();
            idlepool.pop_front();
            return std::shared_ptr<TObject>(
                ptr,
                [&](TObject *p) -> void
                { 
                    idlepool.push_back(p);
                });
        }
    }
    size_t getsize() const
    {
        return idlepool.size();
    }
    void clear()
    {
        for (auto &pobj : idlepool)
        {
            delete pobj;
            pobj = nullptr;
        }
        idlepool.clear();
    }
};
#endif

第三代对象池（单独封装了删除器，对对象池个数进行限制）

#ifndef OBJECTPOOL3_HPP
#define OBJECTPOOL3_HPP

#include <list>
#include <memory>
#include <iostream>
using namespace std;

template <class TObject>
class ObjectPool
{
private:
    std::list<TObject *> idlepool;
    size_t maxTotal; // 8 maxtotal（最大对象个数），
    size_t maxIdle;  // 6，maxidle（最大空闲对象个数，就是在池子里的个数）
    size_t totalObject = 0;//totalObject（现有对象个数）

    void release(TObject *ptr)
    {
        if(idlepool.size() < maxIdle)//对象池允许放入的对象个数
        {
            idlepool.push_back(ptr);
        }
        else
        {
            --totalObject;
            delete ptr;
            cout<<"空闲池已满, 直接删除object"<<endl;
        }
    }
public:
    ObjectPool(size_t maxtotal = 8, size_t maxidle = 6)
        :maxTotal(maxtotal),maxIdle(maxidle) 
    {}
    ~ObjectPool()
    {
        clear();
    }
    ObjectPool(const ObjectPool &) = delete; // C++11
    ObjectPool &operator=(const ObjectPool &) = delete;

public:
    template <class... Args>
    std::shared_ptr<TObject> acquire(Args &&...args)
    {
        if (totalObject < maxTotal && idlepool.empty())
        //如果对象池为空并且 现有对象个数 <  最大对象个数
        {
            ++totalObject;
            return std::shared_ptr<TObject>(
                new TObject(std::forward<Args>(args)...),
                [&](TObject *p) -> void
                {
                    release(p);
                });
        }
        else if(!idlepool.empty())
        {
            auto ptr = idlepool.front();
            idlepool.pop_front();
            return std::shared_ptr<TObject>(
                ptr,
                [&](TObject *p) -> void
                {
                    release(p);
                });
        }
        //已达到最大对象个数，或者对象池为空并且无法创建新资源
        return std::shared_ptr<TObject>(nullptr);
    }
    size_t getIdleObjectNum() const
    {
        return idlepool.size();
    }
    size_t getTotalObjectNum() const 
    {
        return totalObject;
    }
    size_t getActivateObejctNum() const
    {
        return totalObject - idlepool.size();
    }
    void clear()
    {
        for (auto &pobj : idlepool)
        {
            delete pobj;
            pobj = nullptr;
        }
        idlepool.clear();
    }
};
#endif

第四版对象池(对于多线程加入了互斥锁，条件变量，等待时间）

#ifndef OBJECTPOOL4_HPP
#define OBJECTPOOL4_HPP

#include <list>
#include <memory>
#include <iostream>
#include <mutex>
#include <condition_variable>
using namespace std;

template <class TObject>
class ObjectPool
{
private:
    std::list<TObject *> idlepool;
    size_t maxTotal; // 8 maxtotal（最大对象个数），
    size_t maxIdle;  // 6 maxidle（最大空闲对象个数，
    size_t totalObject = 0;//totalObject（现有对象个数）
    size_t maxWaitTime = 2; ///10;
    std::mutex m_mutex;
    std::condition_variable m_cv;

    void release(TObject *ptr)
    {
        std::unique_lock<std::mutex> lock(m_mutex); 
        if(idlepool.size() < maxIdle)
        {
            idlepool.push_back(ptr);
        }
        else
        {
            --totalObject;
            delete ptr;
            cout<<"空闲池已满, 直接删除object"<<endl;
        }
        m_cv.notify_all();
    }
public:
    ObjectPool(size_t maxtotal = 8, size_t maxidle = 6)
        :maxTotal(maxtotal),maxIdle(maxidle) 
    {}
    ~ObjectPool()
    {
        clear();
    }
    ObjectPool(const ObjectPool &) = delete; // C++11
    ObjectPool &operator=(const ObjectPool &) = delete;

public:
    template <class... Args>
    std::shared_ptr<TObject> acquire(Args &&...args)
    {
        std::unique_lock<std::mutex> lock(m_mutex);
        while(idlepool.empty() && totalObject >= maxTotal)
        {
           // m_cv.wait(lock);
           //自己设置等待时间
           if(std::cv_status::timeout == 
               m_cv.wait_for(lock,std::chrono::milliseconds(maxWaitTime*1000)))
           {
               cout<<"timeout wait ... "<<endl;
               return std::shared_ptr<TObject>(nullptr);
           }
        }
        if (totalObject < maxTotal && idlepool.empty())
        {
            ++totalObject;
            return std::shared_ptr<TObject>(
                new TObject(std::forward<Args>(args)...),
                [&](TObject *p) -> void
                {
                    release(p);
                });
        }
        else if(!idlepool.empty())
        {
            auto ptr = idlepool.front();
            idlepool.pop_front();
            return std::shared_ptr<TObject>(
                ptr,
                [&](TObject *p) -> void
                {
                    release(p);
                });
        }
        //return std::shared_ptr<TObject>(nullptr);
    }
    size_t getIdleObjectNum() const
    {
        return idlepool.size();
    }
    size_t getTotalObjectNum() const 
    {
        return totalObject;
    }
    size_t getActivateObejctNum() const
    {
        return totalObject - idlepool.size();
    }
    void clear()
    {
        for (auto &pobj : idlepool)
        {
            delete pobj;
            pobj = nullptr;
        }
        idlepool.clear();
    }
};
#endif
沖田縂司
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++面试题个人汇总
qq_41046887的博客
11-16 451
有一些是自己总结的，有一些是借鉴前辈们的文章的，希望能给大家带来帮助。 目录 一、 基础 面向对象的特征 继承关系 虚继承与虚基类 使一个类不能继承的方法 多态 虚函数定义以及其作用 虚函数表 不能声明为虚函数的函数 构造函数、析构函数与抛出异常 纯虚函数 虚函数与纯虚函数的区别？ C++源文件从文本到可执行文件经历的过程 编译期间的错误、链接期间的错误 C++11新特性 智能指针 Static的用法 Const的用法 强制类型转换 模板 C++内存管理 堆与栈的区别 malloc底层原理 new的操作原
Python中lambda表达式定义函数示例
04-01
使用环境：需要先安装PyCharm（请自己百度下载安装），以及然后官网上下载Python 2.7版本，以及Python 3.7版本后，安装在自己的电脑上。...目的：帮助理解lambda表达式定义函数在Python中的具体使用。
【QandA C++】C++11新特性、Lambda表达式、左值引用、右值引用、完美转发、智能指针、move、强制类型转换等重点知识汇总
qq_68993495的博客
09-24 192
传统的C++语法中就有引用的语法，而C++11中新增了右值引用的语法特性，为了进行区分，于是将C++11之前的引用就叫做左值引用。但是无论左值引用还是右值引用，
【C++】C++11（万能模版、完美转发，可变参数模版，lambda表达式，包装器function+bind绑定）
ZZZCCC的博客
10-07 844
定义了一个可以调用的对象 / 匿名函数，一般定义在局部，特点是可以深度绑定了局部的数据。lambda表达式，实际上是一个匿名函数，实际上是在定义一个函数（局部的函数）lambda表达式通常是用来定义小函数lambda表达式在局部是很好用的，最特别的就是捕捉列表Add叫lambda表达式的对象 – lambda定义的是一个对象。lambda表达式书写格式：lambda表达式各部分说明：捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数。
可变参数模板、右值引用带来的移动语义完美转发、lambda表达式的理解
hanhan的博客
03-10 420
可变参数模板 可变参数模板对参数进行了高度泛化，可以表示任意数目、任意类型的参数： 语法为：在class或者typename后面带上省略号。 Template<class ... T> void func(T ... args) { // } T:模板参数包，args叫做函数参数包 省略号作用： 1、声明一个包含0到任意个模板参数的参数包 2、在模板定义的右边，可以将参数包展开一个个独立的参数 c++11可以使用递归函数的方式展开参数包，获得可变参数的每个值。不过这个需要提供一个参数包展开函
C++11 在析构函数中执行lambda表达式(std::function)捕获this指针的陷阱
10km的专栏
12-03 8732
lambda表达式是C++11最重要也最常用的一个特性之一。lambda来源于函数式编程的概念，也是现代编程语言的一个特点。 关于lambda表达式的概念并不是本文的重点，网上可以找到无数的写得极好的文章介绍它。我想说的是善用lambda表达式，将给C++编程带来极大的便利，这是本人最近学习C++11以来真实深切的感受，但是有时候误用lambda表达式也会给编程带来极大的隐患，本文以最近的经历说明
智能指针之共享指针shared_ptr、弱指针weak_ptr、独占式指针unique_ptr
qq_43148810的博客
10-07 2593
@著作权归作者所有：来自CSDN博客作者大胡子的艾娃的原创作品，如需转载，请注明出处https://blog.csdn.net/qq_43148810，否则将追究法律责任。 如有错误的地方欢迎指正，谢谢! class MyClass { public: MyClass(int m = 0) :M(m){ std::cout << "构造 " << M << std::endl; } MyClass(MyClass& myC) :M(myC.M){
Python学习总结
Jack_Nink的博客
10-09 331
本文为个人学习笔记，将会记录个人的学习Python时的过程，部分为其他博客整理内容，如有侵权，联系删除
c++智能指针（unique_ptr 、shared_ptr、weak_ptr、auto_ptr）
weixin_30600503的博客
05-28 92
一、前序 什么是智能指针？ ——是一个类，用来存储指针（指向动态分配对象也就是堆中对象的的指针）。 c++的内存管理是让很多人头疼的事，当我们写一个new语句时，一般就会立即把delete语句直接也写了，但是我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的delete语句就返回了，如果我们不在每一个可能跳转或者返回的语句前释放资源，就会造成内存泄露。使用...
谷歌C++编程规范
null_one的博客
03-17 691
谷歌C++编程规范
lambda-logger-node:一个中间件记录器，该记录器实现了可在AWS NodeJS Lambdas中使用的MDC记录模式
05-02
进行日志调用时，将首先放置日志级别和消息，然后是包含消息和自定义属性的JSON字符串化对象。 由于v3 lambda-logger-node仅支持包装异步函数处理程序。 快速开始 // lambda.js const { Logger } = require ( '...
java8stream源码-java8:Java8——函数式编程
06-04
—— 函数式编程 介绍 该存储库包含例如 Java 8 In Action 和 Java 8 Lambdas Pragmatic Functional Programming 一书中的源代码。 同时自己也做了一些扩展使用，修复了源码中的bug。 例如 Java 8 In Action 中的源...
GPS载波相位测量中LAMBDA算法整周模糊度求解程序_姿态动态测量
05-01
GPS载波相位测量中LAMBDA算法整周模糊度求解程序；是GPS姿态动态测量入门级算法。(ambiguity solution for gps in carrier measurement,is the basic algrithom for gps attitude measurement on the fly....
全连接神经网络实现Fashion-MNIST数据集图像分类（可运行）.zip
08-23
权重衰减（通过lambd 来调整， lambd = 0 即不使用此方法） 丢弃法（通过定义模型时选择） 4.损失函数（咱们的代码只用了一种） 5.优化方法（咱们的代码只用了一种） 6.训练模型（迭代周期数num_epochs和学习率lr...
FME学习之旅---day27
summer_corner的博客
05-17 197
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1098
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 673
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
web安全学习笔记（18）
最新发布
m0_58875569的博客
05-18 610
记一下第31-32节课的内容。未授权访问漏洞；逻辑漏洞之任意用户密码重置的7种常用姿势
深度学习网络中lambd
07-17
在深度学习网络中，Lambda（&lambda;）通常表示正则化参数，用于控制模型的复杂度。正则化是一种用于减少模型过拟合的技术，通过在损失函数中添加一个正则化项来约束模型的权重。Lambda的值越大，正则化的效果就越明显，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值