exchange.hpp交换机模块

于 2024-08-12 11:37:46 发布
阅读量420 收藏 13
点赞数 8
分类专栏： MQ项目 文章标签： c++ git rabbitmq 后端 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzfnb666/article/details/141124098
版权

一.Exchange相关类介绍

二.Exchange类的实现

交换机类型

对于 RabbitMQ 来说, 主要⽀持四种交换机类型： 
• Direct 
• Fanout 
• Topic 
• Header 
其中 Header 这种⽅式⽐较复杂, ⽐较少⻅。常⽤的是前三种交换机类型，项⽬中也主要实现这三种 
• Direct: ⽣产者发送消息时, 指定被该交换机绑定的所有队列中满足(RoutingKey==BindingKey)的
• Fanout: ⽣产者发送的消息会被复制到该交换机绑定的所有队列中  
• Topic: 绑定队列到交换机上时, 指定⼀个字符串为 BindingKey。发送消息指定⼀个字符串为 
RoutingKey。当 RoutingKey 和 BindingKey满⾜⼀定的匹配条件的时候, 则把消息投递到指定队列

交换机类型的定义

// 交换机类型
enum ExchangeType
{
    UNKNOWNTYPE = 0;
    DIRECT = 1;
    FANOUT = 2;
    TOPIC = 3;
};

// 消息投递模式（决定是否持久化）
enum DeliverMode
{
    NORMAL = 0;
    UNDURABLE = 1;
    DURABLE = 2;
};

Exchange类的相关接口

主要成员变量

  • _name：std::string 类型，表示交换机的名称。
  • _type：msg::ExchangeType 类型，表示交换机的类型。
  • _durable：bool 类型，表示交换机是否持久化。
  • _auto_del：bool 类型，表示交换机是否自动删除。
  • _args：google::protobuf::Map<std::string, std::string> 类型，用于存储交换机的其他参数。这个 Map 用于键值对存储交换机的自定义属性。
std::string _name;                                     // 交换机名称
msg::ExchangeType _type;                               // 交换机类型
bool _durable;                                         // 是否持久化
bool _auto_del;                                        // 是否自动删除
google::protobuf::Map<std::string, std::string> _args; // 其它参数

公有成员函数

setArgs 函数：
  • 用于从格式化字符串中解析出参数并存储到 _args 成员变量中。格式化字符串的格式是 key=val&key=val...，多个键值对通过 & 符号分隔。
  • 实现思路：首先将字符串按 & 进行分割，然后对于每个键值对，按 = 分割为键和值，并存入 _args 中。如果格式错误（找不到 =），则记录错误日志并终止程序。
void setArgs(const std::string &str_args)
{
    std::vector<std::string> args;
    size_t sz = StrHelper::split(str_args, "&", args);
    for (auto &kv : args)
    {
        size_t pos = kv.find("=");
        if (pos == std::string::npos)
        {
            ELOG("Exchange args format error:%s", kv.c_str());
            assert(0);
        }
        std::string key = kv.substr(0, pos);
        std::string val = kv.substr(pos + 1);
        _args[key] = val;
    }
}
getArgs 函数：
  • 将 _args 成员变量中的kv参数转换为格式化字符串，格式同上。它遍历 _args Map，将每个键值对拼接为字符串并以 & 符号分隔。
std::string getArgs()
{
    std::string ret;
    for (auto &kv : _args)
    {
        ret += kv.first + "=" + kv.second + "&";
    }
    return ret;
}

三.ExchangeMapper类的实现

ExchangeMapper 类负责将 Exchange 对象的属性持久化到数据库中，并提供了对这些数据的插入、删除和查询等操作。它通过 SqliteHelper 类与 SQLite 数据库进行交互，确保 Exchange 对象的信息能够在数据库中保存和恢复。

主要成员变量

  • sql_helper：SqliteHelper 类型，用于管理与 SQLite 数据库的连接和操作

构造函数

  • ExchangeMapper(const std::string &dbname)：构造函数接受一个数据库文件的路径 dbname，并使用 SqliteHelper 进行数据库连接的初始化。如果数据库文件所在路径不存在，则会自动创建。同时，构造函数会调用 createTable 方法创建存储 Exchange 信息的表。

公有成员函数

createTable

用于在数据库中创建存储 Exchange 对象信息的表 exchange_table。表中包含以下字段：

args：存储其他参数的字符串。

auto_del：是否自动删除。

durable：是否持久化。

type：交换机类型。

name：交换机名称，作为主键。

void createTable()
{
    std::stringstream sql;
    sql << "create table if not exists exchange_table\
    ('name' varchar(64) primary key,\
    type int,durable int,auto_del int,args varchar(128));";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("ExchangeMapper create table error!");
        assert(0);
    }
}
dropTable
  • 用于删除 exchange_table 表
void dropTable()
{
    std::stringstream sql;
    sql << "drop table if exists exchange_table;";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("ExchangeMapper drop table error!");
        assert(0);
    }
}
insert
  • 将一个 Exchange 对象插入到 exchange_table 表中。它将对象的各个成员变量转化为 SQL 语句中的对应字段值，并执行插入操作。
void insert(Exchange::ptr &exchange_ptr)
{
    std::stringstream sql;
    sql << "insert into exchange_table values('" << exchange_ptr->_name << "'," << exchange_ptr->_type << "," << exchange_ptr->_durable << ","
        << exchange_ptr->_auto_del << ",'"
        << exchange_ptr->getArgs() << "');";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("ExchangeMapper insert error!");
        assert(0);
    }
}
remove
  • 从 exchange_table 表中删除指定名称的 Exchange 对象
void remove(const std::string &name)
{
    std::stringstream sql;
    sql << "delete from exchange_table where name='" << name << "';";
    if (!sql_helper.exec(sql.str(), nullptr, nullptr))
    {
        ELOG("ExchangeMapper remove error!");
        assert(0);
    }
}
recover
  • 从 exchange_table 表中查询所有的 Exchange 对象，并将它们恢复为 Exchange 对象存储在一个哈希表（exchange_map）中返回。该函数使用一个回调函数 exchangeMapCb 处理查询结果，将每一行记录转化为 Exchange 对象。

using exchange_map = std::unordered_map<std::string, Exchange::ptr>;

exchange_map recover()
{
    exchange_map ret;
    std::stringstream sql;
    sql << "select * from exchange_table;";
    if (!sql_helper.exec(sql.str(), exchangeMapCb, &ret))
    {
        ELOG("ExchangeMapper recover error!");
        assert(0);
    }
    return ret;
}
exchangeMapCb
  • 该静态回调函数在 recover 函数中被调用，用于将数据库查询结果中的每一行转化为一个 Exchange 对象，并将其存储到 exchange_map 中。
static int exchangeMapCb(void *args, int rows, char **ret, char **fields)
{
    Exchange::ptr exchange_ptr = std::make_shared<Exchange>();
    exchange_map *map_ptr = (exchange_map *)args;
    exchange_ptr->_name = ret[0];
    exchange_ptr->_type = (msg::ExchangeType)std::stoi(ret[1]);
    exchange_ptr->_durable = std::stoi(ret[2]);
    exchange_ptr->_auto_del = std::stoi(ret[3]);
    if (ret[4])
    {
        exchange_ptr->setArgs(ret[4]);
    }
    map_ptr->insert(std::make_pair(exchange_ptr->_name, exchange_ptr));
    return 0;
}

四.ExchangeManager类的实现

ExchangeManager 类用于管理系统中的 Exchange 对象，并提供声明、删除、查询、判断存在性以及清理等功能。该类在内部通过一个 ExchangeMapper 实例与数据库交互，以实现 Exchange 对象的持久化和恢复。

主要成员变量

  • _mutex：std::mutex 类型，用于确保多线程环境下对 _exchanges 数据结构的安全访问。
  • _mapper：ExchangeMapper 类型，用于与数据库进行交互，负责 Exchange 对象的持久化操作。
  • _exchanges：exchange_map 类型，用于在内存中存储所有当前管理的 Exchange 对象

构造函数

  • ExchangeManager(const std::string &dbname)：构造函数接受一个数据库文件的路径 dbname，通过 ExchangeMapper 从数据库中恢复已存储的 Exchange 对象到内存中的 _exchanges 哈希表。

成员函数(增删查)

declareExchange 函数：

声明一个 Exchange 对象，如果该名称的 Exchange 已存在则直接返回 true。如果不存在，则创建一个新的 Exchange 对象并插入到 _exchanges 中，并在持久化标志 _durable 为 true 时，将其插入到数据库中。

bool declareExchange(const std::string &name, msg::ExchangeType type,
                     bool durable,
                     bool auto_del,
                     google::protobuf::Map<std::string, std::string> args)
{
    std::unique_lock<std::mutex> lock(_mutex);
    auto it = _exchanges.find(name);
    if (it != _exchanges.end())
    {
        ILOG("ExchangeManager declareExchange:%s already exists!", name.c_str());
        return true;
    }
    Exchange::ptr exchange_ptr = std::make_shared<Exchange>(name, type, durable, auto_del, args);
    _exchanges.insert(std::make_pair(name, exchange_ptr));
    if (exchange_ptr->_durable == true)
        _mapper.insert(exchange_ptr);
    return true;
}
removeExchange 函数：
  • 删除一个指定名称的 Exchange 对象。如果该对象存在且是持久化的，则同时从数据库中删除该记录。
bool removeExchange(const std::string &name)
{
    std::unique_lock<std::mutex> lock(_mutex);
    auto it = _exchanges.find(name);
    if (it == _exchanges.end())
    {
        ILOG("ExchangeManager removeExchange not found!");
        return true;
    }
    _exchanges.erase(it);
    if (it->second->_durable)
        _mapper.remove(name);
    return true;
}
selectExchange 函数：
  • 获取指定名称的 Exchange 对象的智能指针，如果未找到则返回一个空的智能指针
Exchange::ptr selectExchange(const std::string &name)
{
    std::unique_lock<std::mutex> lock(_mutex);
    auto it = _exchanges.find(name);
    if (it == _exchanges.end())
        return Exchange::ptr();
    else
        return it->second;
}
exists 函数：
bool exists(const std::string &name)
{
    std::unique_lock<std::mutex> lock(_mutex);
    auto it = _exchanges.find(name);
    return it != _exchanges.end();
}
clear 函数：

清理内存中的 _exchanges 哈希表，并删除数据库中的 exchange_table 表。

void clear()
{
    std::unique_lock<std::mutex> lock(_mutex);
    _exchanges.clear();
    _mapper.dropTable();
}
size 函数：
size_t size()
{
    std::unique_lock<std::mutex> lock(_mutex);
    return _exchanges.size();
}

五.exchange.hpp所有代码

#pragma once

#include "../common_mq/helper.hpp"
#include "../common_mq/logger.hpp"
#include "../common_mq/msg.pb.h"
#include <string>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <cassert>
#include <cstring>
#include <google/protobuf/map.h>
namespace mq
{
    struct Exchange
    {
        using ptr = std::shared_ptr<Exchange>;
        Exchange() {}
        Exchange(const std::string &name, msg::ExchangeType type,
                 bool durable,
                 bool auto_del,
                 const google::protobuf::Map<std::string, std::string> &args)
            : _name(name),
              _type(type),
              _durable(durable),
              _auto_del(auto_del),
              _args(args) {}

        // args存储键值对，在存储数据库的时候，会组织一个格式字符串进行存储 key=val & key=val....
        // 内部解析str_args字符串，将内容存储到成员中
        void setArgs(const std::string &str_args)
        {
            std::vector<std::string> args;
            size_t sz = StrHelper::split(str_args, "&", args);
            for (auto &kv : args)
            {
                size_t pos = kv.find("=");
                if (pos == std::string::npos)
                {
                    ELOG("Exchange args format error:%s", kv.c_str());
                    assert(0);
                }
                std::string key = kv.substr(0, pos);
                std::string val = kv.substr(pos + 1);
                _args[key] = val;
                // ILOG("Exchange args:%s", kv.c_str());
            }
        }
        std::string getArgs()
        {
            std::string ret;
            for (auto &kv : _args)
            {
                ret += kv.first + "=" + kv.second + "&";
            }

            return ret;
        }

        std::string _name;                                     // 交换机名称
        msg::ExchangeType _type;                               // 交换机类型
        bool _durable;                                         // 是否持久化
        bool _auto_del;                                        // 是否自动删除
        google::protobuf::Map<std::string, std::string> _args; // 其它参数
};

    using exchange_map = std::unordered_map<std::string, Exchange::ptr>;

    // 在数据库中 存储exchange信息
    class ExchangeMapper
    {
    public:
        ExchangeMapper(const std::string &dbname)
            : sql_helper(dbname)
        {
            // 数据库有path即可，open时自动创建文件
            std::string path = FileHelper::getParentDirName(dbname);
            FileHelper::createDir(path);
            if (!sql_helper.open())
            {
                ELOG("ExchangeMapper open error!");
                assert(0);
            }
            // std::cout<<"创建表！！！"<<std::endl;
            createTable();
        }
        ~ExchangeMapper() {}
        // 1.创建/删除Exchange表
        void createTable()
        {
            // std::cout<<"创建表！！！"<<std::endl;
            std::stringstream sql;
            sql << "create table if not exists exchange_table\
            ('name' varchar(64) primary key,\
            type int,durable int,auto_del int,args varchar(128));";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("ExchangeMapper create table error!");
                assert(0);
            }
        }
        void dropTable()
        {
            std::stringstream sql;
            sql << "drop table if exists exchange_table;";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("ExchangeMapper drop table error!");
                assert(0);
            }
        }
        // 2.插入/删除Exchange
        void insert(Exchange::ptr &exchange_ptr)
        {
            std::stringstream sql;
            sql << "insert into exchange_table values('" << exchange_ptr->_name << "'," << exchange_ptr->_type << "," << exchange_ptr->_durable << ","
                << exchange_ptr->_auto_del << ",'"
                << exchange_ptr->getArgs() << "');";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("ExchangeMapper insert error!");
                assert(0);
            }
        }
        void remove(const std::string &name)
        {
            std::stringstream sql;
            sql << "delete from exchange_table where name='" << name << "';";
            if (!sql_helper.exec(sql.str(), nullptr, nullptr))
            {
                ELOG("ExchangeMapper remove error!");
                assert(0);
            }
        }

        // 3.查询所有的Exchange，返回一个哈希表
        // 将数据库中的Exchange恢复到内存中，组织一个map并返回
        exchange_map recover()
        {
            exchange_map ret;
            std::stringstream sql;
            sql << "select * from exchange_table;";
            if (!sql_helper.exec(sql.str(), exchangeMapCb, &ret))
            {
                ELOG("ExchangeMapper recover error!");
                assert(0);
            }
            return ret;
        }

    private:
        static int exchangeMapCb(void *args, int rows, char **ret, char **fields)
        {
            Exchange::ptr exchange_ptr = std::make_shared<Exchange>();
            exchange_map *map_ptr = (exchange_map *)args;
            exchange_ptr->_name = ret[0];
            exchange_ptr->_type = (msg::ExchangeType)std::stoi(ret[1]);
            exchange_ptr->_durable = std::stoi(ret[2]);
            exchange_ptr->_auto_del = std::stoi(ret[3]);
            // 避免args为空时出错
            if (ret[4])
            {
                // ILOG("有其它参数，setArgs");
                // std::cout<<"ret[4]"<<ret[4]<<std::endl;
                exchange_ptr->setArgs(ret[4]);
            }
            else
            {
                ILOG("没有其它参数");
            }

            map_ptr->insert(std::make_pair(exchange_ptr->_name, exchange_ptr));
            return 0;
        }

    private:
        SqliteHelper sql_helper;
    };
    // 对外Exchange管理类
    class ExchangeManager
    {
    private:
        std::mutex _mutex;
        ExchangeMapper _mapper;
        exchange_map _exchanges;

    public:
        using ptr = std::shared_ptr<ExchangeManager>;
        ExchangeManager(const std::string &dbname)
            : _mapper(dbname)
        {
            _exchanges = _mapper.recover();
            // std::cout<<"recover后的个数"<<_exchanges.size()<<std::endl;
        }
        // 1.声明交换机，没有则创建
        bool declareExchange(const std::string &name, msg::ExchangeType type,
                             bool durable,
                             bool auto_del,
                             google::protobuf::Map<std::string, std::string> args)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            // std::cout<<"声明之前----"<<std::endl;
            // std::cout<<_exchanges.size()<<std::endl;

            auto it = _exchanges.find(name);
            if (it != _exchanges.end()) // 找到了
            {
                std::cout << _exchanges[name]->_args.size() << std::endl;
                ILOG("ExchangeManager declareExchange:%s already exists!", name.c_str());
                return true;
            }
            Exchange::ptr exchange_ptr = std::make_shared<Exchange>(name, type, durable, auto_del, args);
            // std::cout<<"打印的是构建出的对象"<<std::endl;
            // const auto &tmp = exchange_ptr->_args;
            // for(const auto &tmp : exchange_ptr->_args)
            // {
            //     std::cout<<"key:"<<tmp.first<<" value:"<<tmp.second<<std::endl;
            // }
            _exchanges.insert(std::make_pair(name, exchange_ptr));
            // 若持久化则插入数据库
            if (exchange_ptr->_durable == true)
                _mapper.insert(exchange_ptr);
            return true;
        }
        // 2.删除交换机
        bool removeExchange(const std::string &name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _exchanges.find(name);
            if (it == _exchanges.end()) // 没找到
            {
                ILOG("ExchangeManager removeExchange not found!");
                return true;
            }
            // 删除交换机
            _exchanges.erase(it);
            // 若持久化则在数据库中也remove
            if (it->second->_durable)
                _mapper.remove(name);
            return true;
        }
        // 3.获取指定交换机/判断是否存在
        Exchange::ptr selectExchange(const std::string &name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _exchanges.find(name);
            if (it == _exchanges.end()) // 没找到返回空的ptr
                return Exchange::ptr();
            else
                return it->second;
        }
        bool exists(const std::string &name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            auto it = _exchanges.find(name);
            if (it == _exchanges.end()) // 没找到
                return false;
            else
                return true;
        }
        // 4.清理数据结构
        void clear()
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _exchanges.clear();
            _mapper.dropTable();
        }
        size_t size()
        {
            std::unique_lock<std::mutex> lock(_mutex);
            return _exchanges.size();
        }
    };
};

乄北城以北乀
关注
  • 8
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机后缀名
fengmingyu的专栏
03-22 1万+
http://java.mblogger.cn/zhangpoo/archive/082007.aspx.那么你的计算机能有多少类型后缀名序号 后缀名1 3gp2 _ls3 a4 ab5 acb6 acf7 acl8 aco9 alx10 amr11 ani12 api13 apl14 app15 aps16 art17 arx18 as19 asa20 asd21 ashx22 asl23
ØMQ中文翻译文档
热门推荐
kevin的博客
08-26 1万+
英语原文链接 翻译文档已上传到本人GitHub，目前只翻译了一部分，很多都是直译(英语一般==)，欢迎一起来翻译~ 如果您需要转载，请注明出处。 ØMQ - The Guide [Table of Contents](javascript:
单招十类（计算机基础）知识点整理【备考版本】
Lee's Blog
01-03 2409
计算机基础-知识点总结整理（一）基础理论考试内容1.信息、数据及通信的概念，计算机的发展历史与分类等。2.进制的概念及换算。3.信息安全基本知识、病毒及防治基本知识、社会信息道德及版权与知识产权的知识等。4.计算机硬件及相关设备的基础知识。5.数据存储及换算等。6.各种常用文件扩展名的意义等。（二）应用能力考试内容1.操作系统的使用2.网络基础知识及因特网的应用3.文字处理（Word）基本知识4.电子表格（Excel） 基本知识5.幻灯片（PowerPoint） 基本知识
java面试概要
zbwsxbc的博客
04-25 1326
String是final修饰的，不可变，每次操作都会产生新的String对象 StringBuffer和StringBuilder都是在原对象上操作 StringBuffer是线程安全的，StringBuilder是线程不安全的 StrubgVffer方法都是synchronized修饰的 性能：StringBuilder>StringBuffer >String 使用场景：经常需要改变字符串内容时使用后面两个 优先使用StringBuilder,多线程使用共享变量是使用StringBuffer
专业术语常用名词缩写中英文对照
weixin_30493401的博客
08-09 2246
A:Actuator 执行器A:Amplifier 放大器A:Attendance员工考勤A:Attenuation衰减AA:Antenna amplifier 开线放大器AA:Architectural Acoustics建筑声学AC:Analogue Controller 模拟控制器ACD:Aut...
专用名词
米册之都
11-15 3178
 A:  Actuator 执行器A:  Amplifier 放大器A:  Attendance员工考勤A:  Attenuation衰减AA:  Antenna amplifier 开线放大器AA:  Architectural Acoustics建筑声学AC:  Analogue Controller 模拟控制器ACD:  Automatic Call Distribution 自动分配话务A
通信专业英语词汇
我不是技术牛人 我是L.L.H
09-20 5492
。
电子类术语
freezing point·J
04-23 3957
A:Actuator 执行器A:Amplifier 放大器A:Attendance员工考勤A:Attenuation衰减AA:Antenna amplifier 开线放大器AA:Architectural Acoustics建筑声学AC:Analogue Controller 模拟控制器ACD:Automatic Call
QT中创建.hpp文件以及将.hpp文件包含到工程
01-08
QT中没有创建.hpp文件的功能，但我们可以手动创建。 1.将.cpp文件中的类实现函数全部复制到.h文件中，然后文件夹目录中找到.h文件，将其手动更名为.hpp。 2.这样，在.pro文件中只需加入 INCLUDEPATH += “C:\Users\...
aa.rar_cxcore.hpp
09-20
"aa.rar_cxcore.hpp"的标题暗示了它包含了一个与图像处理相关的C++类库，这个库的核心是`cxcore.hpp`头文件。`cxcore.hpp`是OpenCV（Open Source Computer Vision Library）的一部分，OpenCV是一个广泛使用的开源库...
cpic.rar_c++ cxcore.hpp_cxcore.hpp
09-19
在C++中，通常会使用OpenCV的I/O模块来加载图像，然后使用窗口函数如`cv::imshow()`显示图像。在“cpic”项目中，开发者可能定义了一个自定义的类，该类封装了这些基本操作，允许用户通过类的方法来创建和显示图像，...
zmq.hpp 头文件
09-17
zmq的cpp。头文件。
json.hpp json库，无需添加依赖库，单个文件，C++可调用
05-28
json.hpp json库，无需添加依赖库，单个文件，C++可调用。自己备份
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 345
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 458
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 313
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ STL专题 list的讲解
Mike的博客
08-07 774
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 319
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
json.hpp下载
11-24
json.hpp是一个开源的C++库，用于解析和生成JSON数据。它非常易于使用，只需包含一个头文件即可。要下载json.hpp，你可以在GitHub上搜索json.hpp或者直接访问它的GitHub仓库。在仓库的Release页面可以找到最新的版本，你可以直接下载该版本的压缩包或者使用git clone命令来克隆整个仓库。下载后，你只需要将json.hpp头文件复制到你的项目中，并在需要使用JSON解析和生成的地方包含该头文件即可开始使用json.hpp库了。 json.hpp具有良好的跨平台性能，支持多种编译器和操作系统。它使用现代C++语法和标准库，因此可以很好地与其他C++项目集成。另外，json.hpp提供了简洁清晰的API，使得操作JSON数据变得非常简单和直观。因此，它在许多C++项目中都被广泛使用。 除了从GitHub上直接下载json.hpp外，你还可以通过包管理工具如Conan、vcpkg等来安装json.hpp。这些包管理工具可以帮助你更方便地管理和更新你的C++库。只需通过相应的命令，你就可以在你的项目中快速集成json.hpp，并开始处理JSON数据了。 总之，下载和使用json.hpp非常方便，你可以直接从GitHub下载它的最新版本，也可以利用包管理工具来安装它。一旦你将json.hpp引入到你的项目中，你就可以轻松地处理JSON数据了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值