【sylar】框架篇-Chapter3-配置模块

最新推荐文章于 2024-05-12 21:58:05 发布
最新推荐文章于 2024-05-12 21:58:05 发布
阅读量666 收藏 3
点赞数 1
分类专栏： 【C++】服务器编程-实战 文章标签： c++ 服务器 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_38647413/article/details/125964892
版权

站在巨人的肩膀上

C++高性能分布式服务器框架

从零开始重写sylar C++高性能分布式服务器框架

概述

  • 从配置文件中加载用户配置，灵活实现用户自己按需配置。
  • 其实最简单的配置文件方式还是 .ini 那种，极其简单。YAML 的好处是支持复杂的数据类型。
  • 这里使用 YAML 作为配置文件，配置名称大小写不敏感，并且支持级别格式的数据类型。
  • 这里支持 STL 容器（vector, list, set, map 等等），支持自定义类型（但需要实现序列化和反序列化方法，也就是两个仿函数）。
  • YAML 语法快速简单入门：https://www.runoob.com/w3cnote/yaml-intro.html

ConfigVarBase

  • 配置变量的基类。
  • 虚基类。包含配置名称和配置描述两个属性。提供 toString() 和 fromString() 两个纯虚函数将参数值转换成 YAML String 和从 YAML String 转成参数的值。

LexicalCast

  • template<class F, class T>。
  • 类型转换模板类(F 源类型, T 目标类型)。
  • 有如下类型转换模块类(用于基本内置类型)：
    template<class F, class T>
class LexicalCast {
public:
	T operator()(const F& v) {
    	return boost::lexical_cast<T>(v);
	}
};
  • 有如下的偏特化：
    • template class LexicalCast<std::string, std::vector >
    • template class LexicalCast<std::vector , std::string>
    • template class LexicalCast<std::string, std::list >
    • template class LexicalCast<std::list , std::string>
    • template class LexicalCast<std::string, std::set >
    • template class LexicalCast<std::set , std::string>
    • template class LexicalCast<std::string, std::unordered_set >
    • template class LexicalCast<std::unordered_set , std::string>
    • template class LexicalCast<std::string, std::map <std::string, T> >
    • template class LexicalCast<std::map <std::string, T>, std::string>
    • template class LexicalCast<std::string, std::unordered_map <std::string, T> >
    • template class LexicalCast<std::unordered_map <std::string, T>, std::string>
  • 该模块最烦琐的部分，以上偏特化的实现均为仿函数。
  • 该实现的精巧之处(模板编程的精巧之处)：比如 LexicalCast<std::string, std::vector >，则先调用 LexicalCast<std::string, std::vector > 版本，在处理每个元素 T 时(这里假设 T 是内置基本数据类型)，则调用 boost::lexical_cast(v) 那个最基础的版本。就算 T 是 std::vector 类型或 std::list 等已经实现偏特化的类型，也可以做到层层嵌套去解析。

ConfigVar

  • template<class T, class FromStr = LexicalCast<std::string, T>, class ToStr = LexicalCast<T, std::string> >。其中，T 是配置项参数，FromStr 是将 YAML String 转成参数的值的仿函数，ToStr 是将参数值转换成 YAML String 的仿函数。
  • 对于每种类型的配置，在对应的 ConfigVar 模板类实例化时都要提供其 FromStr 和 ToStr 两个仿函数，用于实现该类型和 YAML 字符串的相互转换。
  • 配置参数模板子类。继承自 ConfigVarBase。
  • 保存对应类型 T 的参数值。
  • 根据不同的非内置基本类型 T，FromStr 和 ToStr 具有不同的模板偏特化实现。
  • 内含一个 std::map，存放配置变更的回调函数。
  • 提供 setValue() 和 getValue() 函数，其中在 setValue() 函数中，会调用 std::map 中存放的所有回调函数进行通知配置变更。
  • 关于回调函数，提供 addListener()、delListener()、getListener()、clearListener() 四个函数给外界使用。

Config

  • ConfigVar 的管理类。
  • 管理所有的配置项，通过静态函数 GetDatas() 获取缓存的 std::unordered_map<std::string, ConfigVarBase::ptr>。
  • 提供 Lookup(const std::string& name, const T& default_value, const std::string& description = “”) 函数给外界获取/创建对应参数名的配置参数。
  • 提供 Lookup(const std::string& name) 函数给外界查找配置参数。
  • 提供 LoadFromYaml(const YAML::Node& root) 函数给外界使用YAML::Node初始化配置模块。
  • 提供 LoadFromConfDir(const std::string& path, bool force = false) 给外界加载path文件夹里面的配置文件。
  • 值得注意的是 Config 所有函数和变量均为静态的。

大概用法

sylar::ConfigVar<int>::ptr g_int_value_config = sylar::Config::Lookup("system.port", (int)8080, "system port");
  				|
				|
			   \|/
SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "before: " << g_int_value_config->getValue();
  				|
				|
			   \|/
YAML::Node root = YAML::LoadFile("/home/sylar/workspace/sylar/bin/conf/test.yml");
sylar::Config::LoadFromYaml(root);
				|
				|
			   \|/
SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "after: " << g_int_value_config->getValue();

部分相关代码

/**
 * @filename    config.h
 * @brief   配置模块
 * @author  L-ge
 * @version 0.1
 * @modify  2022-06-25
 */
#ifndef __SYLAR_CONFIG_H__
#define __SYLAR_CONFIG_H__

#include <boost/lexical_cast.hpp>
#include <yaml-cpp/yaml.h>
#include <memory>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

#include "log.h"

namespace sylar
{

/**
 * @brief   配置变量的基类
 */
class ConfigVarBase
{
public:
    typedef std::shared_ptr<ConfigVarBase> ptr;
    
    ConfigVarBase(const std::string& name, const std::string& description = "")
        : m_name(name)
        , m_description(description)
    {
        std::transform(m_name.begin(), m_name.end(), m_name.begin(), ::tolower);    // 转小写
    }

    virtual ~ConfigVarBase() {}

    const std::string& getName() const { return m_name; }
    const std::string& getDescription() const { return m_description; }
    
    virtual std::string toString() = 0;
    virtual bool fromString(const std::string& val) = 0;
    virtual std::string getTypeName() const = 0;

protected:
    std::string m_name;
    std::string m_description;
};

/**
 * @brief  类型转换模板类 
 *
 * @tparam F    源类型
 * @tparam T    目标类型
 */
template<class F, class T>
class LexicalCast
{
public:
    T operator()(const F& v)
    {
        return boost::lexical_cast<T>(v);
    }
};

template<class T>
class LexicalCast<std::string, std::vector<T> >
{
public:
    std::vector<T> operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        typename std::vector<T> vec;
        std::stringstream ss;
        for(size_t i=0; i<node.size(); ++i)
        {
            ss.str("");     // 清空流
            ss << node[i];
            vec.push_back(LexicalCast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};

template<class T>
class LexicalCast<std::vector<T>, std::string>
{
public:
    std::string operator()(const std::vector<T>& v)
    {
        YAML::Node node(YAML::NodeType::Sequence);
        for(auto& i : v)
        {
            node.push_back(YAML::Load(LexicalCast<T, std::string>()(i)));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

template<class T>
class LexicalCast<std::string, std::list<T> >
{
public:
    std::list<T> operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        typename std::list<T> vec;
        std::stringstream ss;
        for(size_t i=0; i<node.size(); ++i)
        {
            ss.str("");
            ss << node[i];
            vec.push_back(LexicalCast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};

template<class T>
class LexicalCast<std::list<T>, std::string>
{
public:
    std::string operator()(const std::list<T>& v)
    {
        YAML::Node node(YAML::NodeType::Sequence);
        for(auto& i : v)
        {
            node.push_back(YAML::Load(LexicalCast<T, std::string>()(i)));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

template<class T>
class LexicalCast<std::string, std::set<T> >
{
public:
    std::set<T> operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        typename std::set<T> vec;
        std::stringstream ss;
        for(size_t i=0; i<node.size(); ++i)
        {
            ss.str("");
            ss << node[i];
            vec.insert(LexicalCast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};

template<class T>
class LexicalCast<std::set<T>, std::string>
{
public:
    std::string operator()(const std::set<T>& v)
    {
        YAML::Node node(YAML::NodeType::Sequence);
        for(auto& i : v)
        {
            node.push_back(YAML::Node(LexicalCast<T, std::string>()(i)));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

template<class T>
class LexicalCast<std::string, std::unordered_set<T> >
{
public:
    std::unordered_set<T> operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        typename std::unordered_set<T> vec;
        std::stringstream ss;
        for(size_t i=0; i<node.size(); ++i)
        {
            ss.str("");
            ss << node[i];
            vec.insert(LexicalCast<std::string, T>()(ss.str()));
        }
        return vec;
    }
};

template<class T>
class LexicalCast<std::unordered_set<T>, std::string>
{
public:
    std::string operator()(const std::unordered_set<T>& v)
    {
        YAML::Node node(YAML::NodeType::Sequence);
        for(auto& i : v)
        {
            node.push_back(YAML::Load(LexicalCast<T, std::string>()(i)));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

template<class T>
class LexicalCast<std::string, std::map<std::string, T> >
{
public:
    std::map<std::string, T> operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        typename std::map<std::string, T> vec;
        std::stringstream ss;
        for(auto it=node.begin(); it!=node.end(); ++it)
        {
            ss.str("");
            ss << it->second;
            vec.insert(std::make_pair(it->first.Scalar(), LexicalCast<std::string, T>()(ss.str())));
        }
        return vec;
    }
};

template<class T>
class LexicalCast<std::map<std::string, T>, std::string>
{
public:
    std::string operator()(const std::map<std::string, T>& v)
    {
        YAML::Node node(YAML::NodeType::Map);
        for(auto& i : v)
        {
            node[i.first] = YAML::Load(LexicalCast<T, std::string>()(i.second));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

template<class T>
class LexicalCast<std::string, std::unordered_map<std::string, T> >
{
public:
    std::unordered_map<std::string, T> operator()(const std::string& v)
    {
        YAML::Node node = YAML::Load(v);
        typename std::unordered_map<std::string, T> vec;
        std::stringstream ss;
        for(auto it=node.begin(); it!=node.end(); ++it)
        {
            ss.str("");
            ss << it->second;
            vec.insert(std::make_pair(it->first.Scalar(), LexicalCast<std::string, T>()(ss.str())));
        }
        return vec;
    }
};

template<class T>
class LexicalCast<std::unordered_map<std::string, T>, std::string>
{
public:
    std::string operator()(const std::unordered_map<std::string, T>& v)
    {
        YAML::Node node(YAML::NodeType::Map);
        for(auto& i : v)
        {
            node[i.first] = YAML::Load(LexicalCast<T, std::string>()(i.second));
        }
        std::stringstream ss;
        ss << node;
        return ss.str();
    }
};

/**
 * @brief   配置参数模板子类，保存对应类型的参数值
 *
 * @tparam T    具体的配置参数类型
 * @tparam FromStr  从 std::string 转换成 T 类型的仿函数
 * @tparam T        从 T 类型转换成 std::string 的仿函数
 */
template<class T, 
         class FromStr = LexicalCast<std::string, T>,
         class ToStr = LexicalCast<T, std::string> >
class ConfigVar : public ConfigVarBase
{
public:
    typedef RWMutex RWMutexType;
    typedef std::shared_ptr<ConfigVar> ptr;
    typedef std::function<void (const T& old_value, const T& new_value)> on_change_cb;

    ConfigVar(const std::string& name, const T& default_value, const std::string& description = "")
        : ConfigVarBase(name, description)
        , m_val(default_value)
    {}


    /**
     * @brief   将配置值转换成 YAML String
     */
    std::string toString() override
    {
        try
        {
            RWMutexType::ReadLock lk(m_mutex);
            return ToStr()(m_val);
        }
        catch(std::exception& e)
        {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfigVar::toString exception "
                << e.what() << " convert: " << TypeToName<T>() << " to string"
                << " name=" << m_name;
        }
        return "";
    }

    /**
     * @brief  将 YAML String 转换成配置值 
     */
    bool fromString(const std::string& val) override
    {
        try
        {
            setValue(FromStr()(val));
        }
        catch(std::exception& e)
        {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "ConfigVar::fromString exception " 
                << e.what() << " convert: string to " << TypeToName<T>()
                << " name=" << m_name
                << " - " << val;
        }
        return false;
    }

    const T getValue()
    {
        RWMutexType::ReadLock lk(m_mutex);
        return m_val;
    }

    void setValue(const T& v)
    {
        {
            RWMutexType::ReadLock lk(m_mutex);
            if(v == m_val)
            {
                return;
            }

            // 遍历调用回调函数，通知参数变更
            for(auto& i : m_cbs)
            {
                i.second(m_val, v);
            }
        }
        RWMutexType::WriteLock lk(m_mutex);
        m_val = v;
    }

    std::string getTypeName() const override
    {
        return TypeToName<T>();
    }

    uint64_t addListener(on_change_cb cb)
    {
        static uint64_t s_fun_id = 0;
        RWMutexType::WriteLock lk(m_mutex);
        ++s_fun_id;
        m_cbs[s_fun_id] = cb;
        return s_fun_id;
    }

    void delListener(uint64_t key)
    {
        RWMutexType::WriteLock lk(m_mutex);
        m_cbs.erase(key);
    }

    void clearListener()
    {
        RWMutexType::WriteLock lk(m_mutex);
        m_cbs.clear();
    }

    on_change_cb getListener(uint64_t key)
    {
        RWMutexType::ReadLock lk(m_mutex);
        auto it = m_cbs.find(key);
        return it == m_cbs.end() ? nullptr : it->second;
    }

private:
    RWMutexType m_mutex;
    T m_val;
    std::map<uint64_t, on_change_cb> m_cbs;
};

/**
 * @brief   ConfigVar 的管理类
 */
class Config
{
public:
    typedef std::unordered_map<std::string, ConfigVarBase::ptr> ConfigVarMap;
    typedef RWMutex RWMutexType;

    template<class T>
    static typename ConfigVar<T>::ptr Lookup(const std::string& name,
            const T& default_value, const std::string& description = "")
    {
        RWMutexType::WriteLock lk(GetMutex());
        auto it = GetDatas().find(name);
        if(it != GetDatas().end())
        {
            auto tmp = std::dynamic_pointer_cast<ConfigVar<T> >(it->second);
            if(tmp)
            {
                SYLAR_LOG_INFO(SYLAR_LOG_ROOT()) << "Lookup name=" << name << " exists";
                return tmp;
            }
            else
            {
                SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "Lookup name=" << name
                    << " exists but type not " << TypeToName<T>()
                    << " real_type=" << it->second->getTypeName()
                    << " " << it->second->toString();
                return nullptr;
            }
        }

        // 判断是否含有非法字符
        if(name.find_first_not_of("abcdefghijklmnopqrstuvwxyz._012345678")
                != std::string::npos)
        {
            SYLAR_LOG_ERROR(SYLAR_LOG_ROOT()) << "Lookup name invalid " << name;
            throw std::invalid_argument(name);
        }

        typename ConfigVar<T>::ptr v(new ConfigVar<T>(name, default_value, description));
        GetDatas()[name] = v;
        return v;
    }

    template<class T>
    static typename ConfigVar<T>::ptr Lookup(const std::string& name)
    {
        RWMutexType::ReadLock lk(GetMutex());
        auto it = GetDatas().end();
        if(it == GetDatas().end())
        {
            return nullptr;
        }
        return std::dynamic_pointer_cast<ConfigVar<T> >(it->second);
    }

    static void LoadFromYaml(const YAML::Node& root);

    /**
     * @brief   从配置文件加载配置到缓存
     *
     * @param   path    相对路径
     * @param   force   是否强制更新(不管配置文件是否有变化)，默认为 false
     */
    static void LoadFromConfDir(const std::string& path, bool force = false);
    
    static ConfigVarBase::ptr LookupBase(const std::string& name);
    
    /**
     * @brief   遍历缓存的所有配置项
     *
     * @param   cb  回调函数，形参为每个配置项
     */
    static void Visit(std::function<void(ConfigVarBase::ptr)> cb);

private:
    static ConfigVarMap& GetDatas()
    {
        static ConfigVarMap s_datas;
        return s_datas;
    }

    static RWMutexType& GetMutex()
    {
        static RWMutexType s_mutex;
        return s_mutex;
    }
};

}

#endif


#include "config.h"
#include "env.h"

namespace sylar
{

static sylar::Logger::ptr g_logger = SYLAR_LOG_NAME("system");

ConfigVarBase::ptr Config::LookupBase(const std::string& name)
{
    RWMutexType::ReadLock lk(GetMutex());
    auto it = GetDatas().find(name);
    return it == GetDatas().end() ? nullptr : it->second;
}

static void ListAllMember(const std::string& prefix,
                          const YAML::Node& node,
                          std::list<std::pair<std::string, const YAML::Node> >& output)
{
    if(prefix.find_first_not_of("abcdefghijklmnopqrstuvwxyz._012345678")
            != std::string::npos)
    {
        SYLAR_LOG_ERROR(g_logger) << "Config invalid name: " << prefix << " : " << node;
        SYLAR_LOG_ERROR(g_logger) << prefix << ":" << prefix.find_first_not_of("abcdefghijklmnopqrstuvwxyz._012345678");
        return;
    }

    output.push_back(std::make_pair(prefix, node));
    if(node.IsMap())
    {
        for(auto it=node.begin(); it!=node.end(); ++it)
        {
            ListAllMember(prefix.empty() ? it->first.Scalar() 
                    : prefix + "." + it->first.Scalar(), it->second, output);
        }
    }
}

void Config::LoadFromYaml(const YAML::Node& root)
{
    std::list<std::pair<std::string, const YAML::Node> > all_nodes;
    ListAllMember("", root, all_nodes);     // 平铺所有配置项到 all_nodes 中

    for(auto& i : all_nodes)    // 逐个更新配置
    {
        std::string key = i.first;
        if(key.empty())
        {
            continue;
        }

        std::transform(key.begin(), key.end(), key.begin(), ::tolower);
        ConfigVarBase::ptr var = LookupBase(key);

        if(var)
        {
            if(i.second.IsScalar())
            {
                var->fromString(i.second.Scalar());
            }
            else
            {
                std::stringstream ss;
                ss << i.second;
                var->fromString(ss.str());
            }
        }
    }
}

static std::map<std::string, uint64_t> s_file2modifytime;
static sylar::Mutex s_mutex;

void Config::LoadFromConfDir(const std::string& path, bool force)
{
    std::string absoulte_path = sylar::EnvMgr::GetInstance()->getAbsolutePath(path);
    std::vector<std::string> files;
    FSUtil::ListAllFile(files, absoulte_path, ".yml");  // 获取绝对路径下所有配置文件

    for(auto& i : files)
    {
        // 判断文件修改时间是否有变化，变化才更新
        {
            struct stat st;
            lstat(i.c_str(), &st);
            sylar::Mutex::Lock lk(s_mutex);
            if(!force && s_file2modifytime[i] == (uint64_t)st.st_mtime)
            {
                continue;
            }
            s_file2modifytime[i] = st.st_mtime;
        }

        try
        {
            YAML::Node root = YAML::LoadFile(i);
            LoadFromYaml(root);
            SYLAR_LOG_INFO(g_logger) << "LoadConfFile file=" << i << " ok";
        }
        catch(...)
        {
            SYLAR_LOG_ERROR(g_logger) << "LoadConfFile file=" << i << " failed";
        }
    }
}

void Config::Visit(std::function<void(ConfigVarBase::ptr)> cb)
{
    RWMutexType::ReadLock lk(GetMutex());
    ConfigVarMap& m = GetDatas();
    for(auto it=m.begin(); it!=m.end(); ++it)
    {
        cb(it->second);
    }
}

}

广告时间：基于sylar框架实现的小demo(希望给个star)

基于redis的参数查询服务

江湖人称菠萝包
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sylar-env-1.1.0-1.el7.x86_64.rpm
04-20
sylar-env-1.1.0-1.el7.x86_64.rpm
C++高性能服务器框架 – SYLAR简介
sylar的专栏
06-13 7546
视频地址 [C++高级教程]从零开始开发服务器框架(sylar) 视频教程内容： 1.日志模块 支持流式日志风格写日志和格式化风格写日志，支持日志格式自定义，日志级别，多日志分离等等功能 流式日志使用：SYLAR_LOG_INFO(g_logger) << “this is a log”; 格式化日志使用：SYLAR_LOG_FMT_INFO(g_logger, “%s”, “this...
C++高性能服务器框架 – SYLAR - 线程模块
sylar的专栏
05-22 3062
这里写自定义目录标题线程库选择线程类信号量(Semaphore)互斥量(Mutex)其他 线程库选择 C++11中提供了std::thread, std::mutex, std::condition_variable等线程相关的类。但是还是不够完善，比如没有提供读写锁。没有提供spinlock，虽然c++11里面的atomic可以用来实现CAS锁。 对于高并发服务器来说，很多数据，大多数时候，都...
Sylar服务器框架---线程同步模块
qq_62821433的博客
05-12 364
1.sylar的线程同步模块使用了pthread线程库的互斥量，读写锁，自旋锁。原子锁是使用的c++的2.使用了RALL的方法，即资源构造即初始化，出作用域就析构。避免了我们手动进行资源申请和释放的相关操作。这里具体的操作是Mutex类创建一个对象时通过构造初始化锁，析构时销毁锁；加锁，解锁两个方法（用户不可自己调用）交由ScopedLockImpl<Mutex>类来调用，构造时就加锁，析构时解锁。和muduo中的基本一样。
C++高性能服务器（sylar）日志系统
qq_48185092的博客
10-23 480
最近学完了C++的基础部分，找了个服务器的项目，跟着sylar大佬搭建服务器，这个项目有点难，单是一个日志系统，视频总共才4个小时，我花了一周多的时间才完成，不过在这一周里学到的东西确实很多，一方面是将前面学的基础知识应用到项目中，这段过程个人感觉很重要，这就像是学英语，虽然单词全背会了，但真正在阅读理解中遇到的时候，还是记不到单词的意思。另一方面，跟着大佬敲代码，也渐渐养成了一种良好的编码习惯，以及学到了很多没学过的知识。
sylar库学习-日志系统
m0_55292629的博客
06-13 1618
c++项目学习笔记
C++高性能服务器（sylar）配置系统
qq_48185092的博客
10-31 163
开发人员可以轻松地定义配置项，提供配置名称、配置类型、默认值以及配置项的描述。这使得配置管理变得直观和可控。
sylar：C ++大规模分布式服务器框架，Web服务器，WebSocket服务器，自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块， bytearray序列化，http模块，TcpServer模块，Websocket模块，Https模块等，Smtp邮件模块，MySQL，SQLite3，ORM，Redis，Zookeeper）
01-30
sylar：C ++大规模分布式服务器框架，Web服务器，WebSocket服务器，自定义tcp_server（包含日志模块，配置模块，线程模块，协程模块，协程调度模块，io协程调度模块，hook模块，socket模块， bytearray序列化，http...
Sylar:学习开发Sylar服务器框架
03-29
西拉
C++聊天室服务器，基于sylar框架开发，使用http服务器做资源服务，
最新发布
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。...3
hadoop默认配置文件x-default.xml
07-11
hadoop默认配置文件core-default.xml hdfs-default.xml mapred-default.xml yarn-default.xml
CPU-Z，参数解读
03-10
CPU-Z--参数解读文档，
sylar
10-24
sylar
XXPlayer-android音乐播放器源码.zip
04-12
android 音乐播放器 仅供学习
java图形界面美化包 nimrodlf-1.0b
10-31
该报用于美化java界面，载入包后加入如下代码： try { UIManager.setLookAndFeel("org.jvnet.substance.skin.SubstanceFieldOfWheatLookAndFeel"); } catch (ClassNotFoundException e) { // TODO 自动生成的 ...
vs2008下的opengl配置
03-18
3. **配置项目属性**：启动VS2008，创建一个新的工程。接下来，配置项目的属性以链接GLaux库。进入项目属性，选择“配置属性”->“链接器”->“输入”->“附加依赖项”，在这里添加`opengl32.lib`、`glu32.lib`和`...
【C++模块实现】| 【04】配置模块
weixin_45926547的博客
07-28 2826
定义、加载系统的配置项，可由用户自定义于文件中，通过YAML加载解析配置内容至系统中；
【源码讲解】sylar服务器框架----配置模块
Dereyer的博客
09-13 388
在C++编程语言中，仿函数（Functor）是一种行为类似于函数的对象，可以像函数一样被调用。仿函数是一个类或结构体，它重载了圆括号操作符 "()"，因此可以像函数一样被调用。仿函数可以在算法中使用，例如std::transform()，可以将一个序列中的每个元素映射到另一个序列中。仿函数的好处是可以通过重载操作符来实现更加灵活的行为，例如可以在一个仿函数中保存一些状态信息，或者将它作为一个回调函数来传递给其他函数使用。public:/*** @brief 类型转换。
[源码阅读]——Sylar服务器框架：协程调度模块
weixin_46267443的博客
11-30 2488
源码阅读——sylar服务器框架：协程调度模块
shell scp -r命令
03-15
shell中的scp命令用于在本地主机和远程主机之间复制文件或目录。使用scp命令可以通过网络安全地传输文件。下面是使用scp命令复制文件或目录的示例[^2]： ```shell scp -r source_directory username@destination_host:destination_directory ``` 其中，-r选项表示递归复制整个目录，source_directory是要复制的源文件或目录的路径，username是远程主机的用户名，destination_host是远程主机的IP地址或主机名，destination_directory是目标目录的路径。 例如，要将本地主机上的/var/www/test目录复制到远程主机的/var/www/目录下，可以使用以下命令： ```shell scp -r /var/www/test username@192.168.0.101:/var/www/ ``` 这将递归地复制/var/www/test目录及其所有子目录和文件到远程主机的/var/www/目录下。 请注意，执行此命令时，您需要输入远程主机的密码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值