项目：抓虫记日志系统(四)

最新推荐文章于 2025-12-18 16:28:22 发布
原创 最新推荐文章于 2025-12-18 16:28:22 发布 · 823 阅读 · 33 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #c++

目录：

  1. 目录

    一、引言

    二、局部日志制造器和局部日志器

    三、全局日志制造器和全局日志器

    四、全局日志器的管理器

    五、同步日志器和异步日志器

一、引言

        结合前文，我们实现了日志输出的时间、日志等级、格式化输出内容、异步日志器的缓冲区、异步日志器的输出。实现了日志器大体的框架。

        我们从日志获取到的有效信息、输出到的地方，以及多线程去输出日志要输出的信息用缓冲区类存储多线程日志器输出的信息，一个Buffer类单独管理多线程输出信息，从而避免了输出位置冲突的情况和输出内容完毕清除的情况。为了避免多线程之间的线程冲突，我们使用了互斥锁。互斥锁相当于一个保护机制，他限制了进入线程的数量。但是我们开发时最好还是只允许一个线程访问公共资源。何谓公共资源呢？就是不属于这个函数的外部资源，大家都知道在函数内创建并使用最后在函数内销毁的是临时资源，那与他相对的就是公共资源，将公共资源保护起来，避免收到其他线程的干扰。

        这篇博客小编打算聊聊最后一步全局日志制造器。

        在制造日志器过程中，我们使用指针传递的形式生成的日志器，无需构造中间值传递，非常快速便捷。为了防止指针执行的资源没有得到释放所以我们使用智能指针，智能管理规划好指针的析构工作。同时使用指针访问资源，这样要求日志器全局使用也只需要申请一个全局的智能指针管理存储对象（可以是vector）。我们使用日志器的名称在日志制造器中查找。当然我们通过传递形参告知日志制造器我们要制造的日志器具有什么功能。例如是同步还是异步，落地方向是都包括还是包括哪几个，限定日志等级是什么。

二、局部日志制造器和局部日志器

        为了更好的输出日志等级，我们将日志器做了一点微小的优化，直接将日志等级名作为函数名，封装日志器的输出。

        局部日志制造器，我们只需要创建他就好了，不用将他交给某一全局对象。另外我们原定计划是使用vector线性表来存储好局部日志器的，但是我们一般都是通过日志器的名称来查找日志器。所以我们使用unordered_map，这个unordered_map以后会有详细资料的，大家如果不太了解C++的这个容器的话可以点进下面的链接了解unordered_map容器的接口和大致的一个搜索时间复杂度O(1)：

        https://cplusplus.com/reference/unordered_map/.

        局部日志器我们只需要提供一个通过形参制造日志器的接口就行了，接口返回一个日志器的智能指针。因为局部日志制造器和全局日志制造器有非常多的相似性。所以我们可以通过继承某一个纯虚类搭建一个框架。实现所有纯虚类中的纯虚函数。这样如果我们要进行新的添加日志制造器，也只需要一个新的类去继承这个纯虚类就可以做到快速搭建了。

三、全局日志制造器和全局日志器

        为了满足一些日志器的需要伴随文件开始直到文件的结束。我们使用全局日志器。那我们该如何做到全局呢？其实就和局部日志器不同的是使用一个全局的对象进行管理指向全局的日志器的智能指针。全局的对象内置了一个static对象。需要初始化日志器时再创建，我们称为懒汉模式。

四、全局日志器的管理器

        全局日志器的管理器肯定也是一个static静态对象。由于是全局对象，所以出现一个就够了。所以我们为了添加全局日志器所以我们需要在全局日志器管理器中添加一个引用自身也就是全局日志器管理器的对象。使用时我们再进行创建，创建太早了也是一种对资源的浪费。这就是懒汉模式。先进行创建，再使用，这就是饿汉模式。这两种都是可以的。由于我们需要实例化出对象才可以调用类中的函数，所以我们选择使用饿汉模式。值得一提的是就算我们将函数static，类函数使用了类中的变量不是static，也还是无法调用的。

五、同步日志器和异步日志器

        我们设置类里面包含纯虚函数，让其他类继承这个类，相当于一个框架。框架虽然限制了我们的思维，但是他能够极好地保证了代码的可靠性。

代码如下：

#ifndef __LOGGER_HPP___
#define __LOGGER_HPP___

#include <iostream>
#include <vector>
#include <atomic>
#include <mutex>
#include <memory>
#include <cstdarg>
#include <functional>
#include <unordered_map>
#include "Until.hpp"
#include "Level.hpp"
#include "Format.hpp"
#include "Message.hpp"
#include "Sink.hpp"

#include "Looper.hpp"

namespace Logs
{
    class Logger
    {
    public:
        using Ptr = std::shared_ptr<Logger>;

        Logger( Level::Value& limit_level
            , Formatter::Ptr& formatter
            ,const std::string& logger_name
            ,std::vector<Sink::Ptr>& sinks
            )
            :_limit_level(limit_level)
            ,_formatter(formatter)
            ,_logger_name(logger_name)
            ,_sinks(sinks.begin(),sinks.end())
        {
            ;
        }
        const std::string& loggerName()
        {
            return _logger_name;
        }
        void debug(const std::string& file,size_t line,const std::string& fmt,...)
        {
            if(Level::Value::DEBUG < _limit_level)
            {
                return ;
            }
            va_list ap;
            va_start(ap,fmt);
            char* res;
            int ret = vasprintf(&res,fmt.c_str(),ap);
            if(ret == -1)
            {
                std::cout << "vasprintf failed!!\n";

                return ;
            }
            va_end(ap);
            Serialize(Level::Value::DEBUG,file,line,res);

            free(res);
        }
        void info(const std::string& file,size_t line,const std::string& fmt,...)
        {
            if(Level::Value::INFO < _limit_level)
            {
                return ;
            }
            va_list ap;
            va_start(ap,fmt);
            char* res;
            int ret = vasprintf(&res,fmt.c_str(),ap);
            if(ret == -1)
            {
                std::cout << "vasprintf failed!!\n";

                return ;
            }
            va_end(ap);
            Serialize(Level::Value::INFO,file,line,res);
            
            free(res);
        }
        void warn(const std::string& file,size_t line,const std::string& fmt,...)
        {
            if(Level::Value::WARN < _limit_level)
            {
                return ;
            }
            va_list ap;
            va_start(ap,fmt);
            char* res;
            int ret = vasprintf(&res,fmt.c_str(),ap);
            if(ret == -1)
            {
                std::cout << "vasprintf failed!!\n";

                return ;
            }
            va_end(ap);
            Serialize(Level::Value::WARN,file,line,res);
            
            free(res);
        }
        void error(const std::string& file,size_t line,const std::string& fmt,...)
        {
            if(Level::Value::ERROR < _limit_level)
            {
                return ;
            }
            va_list ap;
            va_start(ap,fmt);
            char* res;
            int ret = vasprintf(&res,fmt.c_str(),ap);
            if(ret == -1)
            {
                std::cout << "vasprintf failed!!\n";

                return ;
            }
            va_end(ap);
            Serialize(Level::Value::ERROR,file,line,res);
            
            free(res);
        }
        void fatal(const std::string& file,size_t line,const std::string& fmt,...)
        {
            if(Level::Value::FATAL < _limit_level)
            {
                return ;
            }
            va_list ap;
            va_start(ap,fmt);
            char* res;
            // vasprintf根据不定参数的列表中的数据进行字符串的初始化。
            // 这res是动态申请的资源，记得释放。
            int ret = vasprintf(&res,fmt.c_str(),ap);
            if(ret == -1)
            {
                std::cout << "vasprintf failed!!\n";

                return ;
            }
            va_end(ap);
            Serialize(Level::Value::FATAL,file,line,res);
            
            free(res);
        }
    //protected:
        virtual void log(const char* str,size_t len) = 0;
        void Serialize(Level::Value level,const std::string& file,size_t line,char* res)
        {
            Message msg(Until::Time::GetTime(),level,file,line,res,_logger_name);
            std::stringstream ss;
            //ss << res << "\n";
            _formatter->format(ss,msg);
            log(ss.str().c_str(),ss.str().size());
        }
    protected:
        std::mutex _mutex;
        std::atomic<Level::Value> _limit_level;
        Formatter::Ptr _formatter;
        std::string _logger_name;
        std::vector<Sink::Ptr> _sinks;
    };
    // 同步日志器。
    class SyncLogger : public Logger
    {
    public:
        SyncLogger(Level::Value& limit_level
            ,Formatter::Ptr& formatter
            ,const std::string& logger_name
            ,std::vector<Sink::Ptr>& sinks
            )
            :Logger(limit_level,formatter,logger_name,sinks)
        {
            ;
        }
        void log(const char* str,size_t len) override
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            if(_sinks.empty())
            {
                return ;
            }
            for(auto& sink : _sinks)
            {
                sink->log(str,len);
            }
        }
    private:
    };
    // 异步日志器。
    class AsyncLogger : public Logger
    {
    public:
        AsyncLogger(Level::Value limit_level
                    ,Formatter::Ptr formatter
                    ,const std::string&  logger_name
                    ,std::vector<Sink::Ptr>& sinks
                    ,AsyncType looper_type = AsyncType::ASYNC_SAFE)
            :Logger(limit_level,formatter,logger_name,sinks)
            ,_looper(std::make_shared<AsyncLooper>(std::bind(&AsyncLogger::realLog,this,std::placeholders::_1),looper_type))
            ,_looper_type(looper_type)
        {
            std::cout << Level::To_String(_limit_level) << "异步日志器: " << _logger_name << "创建成功...\n";
            std::cout << "sink:" << _sinks.size() << "\n";
        }
        // push进缓冲区。 
        void log(const char* str,size_t len) override
        {
            _looper->push(str,len);
        }
        // 设计一个实际落地函数。(将缓冲区的内容落地)
        void realLog(Buffer& buffer)
        {
            if(_sinks.empty())
            {
                return ;
            }
            std::cout << _sinks.size() << std::endl;
            for(auto& sink : _sinks)
            {
                sink->log(buffer.begin(),buffer.readAbleLen());
            }
        }
    private:
        AsyncLooper::Ptr _looper;
        AsyncType _looper_type;
    };

    enum class LoggerType
    {
        LOGGER_ASYNC,
        LOGGER_SYNC
    };

    class LoggerBuilder
    {
    public:
        using Ptr = std::shared_ptr<LoggerBuilder>;
        // LoggerBuilder(LoggerType logger_type
        //            ,AsyncType looper_type
        //            ,Level::Value limit_level
        //            //,Formatter::Ptr& formatter
        //            ,const std::string& logger_name
        //            //,std::vector<Sink::Ptr>& sinks
        //            )
        //     :_logger_type(logger_type)
        //     ,_limit_level(limit_level)
        //     //,_formatter(formatter)
        //     ,_logger_name(logger_name)
        //     //,_sinks(sinks.begin(),sinks.end())
        //     ,_looper_type(looper_type) // 默认是安全的。
        // {
        //     ;
        // }
        LoggerBuilder()
            :_limit_level(Level::Value::DEBUG)
            ,_logger_type(LoggerType::LOGGER_SYNC)
            ,_looper_type(AsyncType::ASYNC_SAFE)
        {}
        void BuildLoggerType(LoggerType type)// 调整为不安全的。
        {
            _logger_type = type;
        }
        void BuildAsyncUnsafe()
        {
            _looper_type = AsyncType::ASYNC_UNSAFE;
        }
        void BuildLoggerName(const std::string& name)
        {
            _logger_name = name;
        }
        void BuildLoggerLevel(Level::Value level)
        {
            _limit_level = level;
        }
        void BuildFormatter(const std::string& pattern)
        {
            _formatter = std::make_shared<Formatter>(pattern);
        }

        template< typename SinkType , typename ...Args >
        void BuildSink(Args&& ...args)
        {
            Sink::Ptr psink = SinkFactory::CreateSink<SinkType>(std::forward<Args>(args)...);
            _sinks.push_back(psink);
        }

        virtual Logger::Ptr Build() = 0;
    protected:
        LoggerType _logger_type;
        AsyncType _looper_type;
        Level::Value _limit_level;
        Formatter::Ptr _formatter;
        std::string _logger_name;
        std::vector<Sink::Ptr> _sinks;
    };

    class LocalLoggerBuilder : public LoggerBuilder
    {
    public:
        // LocalLoggerBuilder(LoggerType logger_type
        //            ,Level::Value limit_level
        //            //,Formatter::Ptr& formatter
        //            ,const std::string& logger_name
        //            //,std::vector<Sink::Ptr>& sinks
        //            ,AsyncType looper_type = AsyncType::ASYNC_SAFE
        //            )
        //     :LoggerBuilder(logger_type,looper_type,limit_level,logger_name)
        // {
        //     ;
        // }
        LocalLoggerBuilder()
            :LoggerBuilder()
        {}
        Logger::Ptr Build() override
        {
            // 日志器的名字是查找日志器的唯一凭证。
            // 不可或缺。
            assert(_logger_name.size());
            // 接下来再慢慢改。
            if(_formatter.get() == nullptr)
            {
                _formatter = std::make_shared<Formatter>();
            }
            if(_sinks.empty())
            {
                BuildSink<StdoutSink>();
            }
            // 异步日志器
            if(_logger_type == LoggerType::LOGGER_ASYNC)
            {
                // Level::Value limit_level
                //     ,Formatter::Ptr formatter
                //     ,const std::string&  logger_name
                //     ,std::vector<Sink::Ptr>& sinks
                //     ,AsyncType looper_type = AsyncType::ASYNC_SAFE
                std::cout << "制造异步日志器" << std::endl;
                std::cout <<"_sinks:" << _sinks.size() << "\n";
                return std::make_shared<AsyncLogger>(_limit_level,_formatter,_logger_name,_sinks,_looper_type);
            }

            // 同步日志器
            // Level::Value& limit_level
            // ,Formatter::Ptr& formatter
            // ,const std::string& logger_name
            // ,std::vector<Sink::Ptr>& sinks
            return std::make_shared<SyncLogger>(_limit_level,_formatter,_logger_name,_sinks);
        }
    };

    class LoggerManager
    {
    public:
        static LoggerManager& getInc()
        {
            // static 是有线程安全的，不用担心会创建多个static对象。
            static LoggerManager self;
            return self;
        }
        void addLogger(Logger::Ptr logger)
        {
            // 访问公共资源时记得加锁。
            if(hasLogger(logger->loggerName()))
            {
                return ;
            }
            std::unique_lock<std::mutex> lock(_mutex);
            _loggers.insert(std::make_pair(logger->loggerName(),logger));
        }
        bool hasLogger(const std::string& name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            std::unordered_map<std::string,Logger::Ptr>::iterator pos = _loggers.find(name);
            if(pos == _loggers.end())
            {
                return false;
            }

            return true;
        }
        Logger::Ptr getLogger(const std::string& name)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            std::unordered_map<std::string,Logger::Ptr>::iterator pos = _loggers.find(name);
            if(pos == _loggers.end())
            {
                return nullptr;
            }

            return pos->second;
        }
        Logger::Ptr rootLogger()
        {
            return _root_logger;
        }
    private:
        // LoggerManage(LoggerType logger_type
        //            ,Level::Value limit_level
        //            //,Formatter::Ptr& formatter
        //            ,const std::string& logger_name
        //            //,std::vector<Sink::Ptr>& sinks
        //            ,AsyncType looper_type = AsyncType::ASYNC_SAFE)
        LoggerManager()
        {
            std::unique_ptr<LoggerBuilder> build(std::make_unique<LocalLoggerBuilder>());
            build->BuildLoggerName("root");
            _root_logger = build->Build();
            _loggers.insert(std::make_pair("root",_root_logger));
        }
    private:
        std::mutex _mutex; 
        Logger::Ptr _root_logger; // 默认日志器。
        std::unordered_map<std::string,Logger::Ptr> _loggers;
    };
    
    // 设计一个全局日志器制造者。
    class GlobalLoggerBuilder : public LoggerBuilder
    {
    public:
        // LocalLoggerBuilder(LoggerType logger_type
        //            ,Level::Value limit_level
        //            //,Formatter::Ptr& formatter
        //            ,const std::string& logger_name
        //            //,std::vector<Sink::Ptr>& sinks
        //            ,AsyncType looper_type = AsyncType::ASYNC_SAFE
        //            )
        //     :LoggerBuilder(logger_type,looper_type,limit_level,logger_name)
        // {
        //     ;
        // }
        GlobalLoggerBuilder(){}
        Logger::Ptr Build() override
        {
            // 日志器的名字是查找日志器的唯一凭证。
            // 不可或缺。
            assert(_logger_name.size());
            // 接下来再慢慢改。
            if(_formatter.get() == nullptr)
            {
                _formatter = std::make_shared<Formatter>();
            }
            if(_sinks.empty())
            {
                BuildSink<StdoutSink>();
            }

            Logger::Ptr logger;

            // 异步日志器
            if(_logger_type == LoggerType::LOGGER_ASYNC)
            {
                logger = std::make_shared<AsyncLogger>(_limit_level,_formatter,_logger_name,_sinks,_looper_type);
            }

            std::make_shared<SyncLogger>(_limit_level,_formatter,_logger_name,_sinks);
            
            LoggerManager::getInc().addLogger(logger);
            return logger;
        }
    };
}

#endif
魈十三
关注
APP爬虫：Airtest的使用和爬取实战详解
数据知道的博客
02-28 7735
Airtest是一个跨平台的自动化测试工具，主要用于移动应用和游戏的UI自动化测试。它支持图像识别、触摸操作、文本输入等功能，能够模拟真实用户的操作行为。此外，Airtest还具备强大的日志记录和报告生成功能，方便开发者进行调试和分析。图像识别：通过截图匹配元素，无需依赖 UI 层次结构。跨平台支持：支持 Android、iOS 和 Windows 应用。简单易用：提供 IDE 和脚本录制功能，降低使用门槛。
实现数据抓取的断点续爬功能：Python爬虫的高效抓取策略
2201_76125261的博客
04-21 663
断点续爬是指在爬虫抓取过程中，如果由于某些原因（如网络中断、服务器封禁等）导致爬虫停止运行，程序能够在重新启动后，继续从最后一个成功抓取的数据点继续抓取，而不必从头开始。这种机制不仅能节省时间和资源，还能避免重复抓取。实现数据抓取的断点续爬功能，不仅能提高爬虫的稳定性和效率，还能避免重复抓取，节省时间和计算资源。在实际应用中，断点续爬的核心是通过记录抓取进度，并根据进度信息恢复抓取任务。通过结合数据库存储、异常处理、去重策略等技术，能够实现高效且可靠的爬虫任务。
工作随笔：利用爬虫抓取系统日志
weixin_64392229的博客
08-29 1444
利用爬虫，简化了每周巡检服务报错的工作，为每一点小进步加油！
玩转代理 IP ：实战爬虫案例
引用原创内容标明出处即可
04-10 2685
在现代互联网环境下，爬虫不仅是数据获取的利器，也成为应对网站反爬机制的技术博弈。而在这场博弈中，"代理 IP" 是核心武器之一。本文将以高匿名的代理ip为核心，结合 Python 实战、代理策略设计、高匿技巧与反封锁优化，全面拆解代理 IP 技术的实际应用路径，并通过完整案例实现一个稳定、高效、抗封锁的爬虫系统。
用 Bright Data 盯 Amazon 价格：告别脱发的零代码神操作
热门推荐
CSDN博客专家，系统架构师，有合作、疑惑请私信博主。
07-23 68万+
用 Bright Data 盯 Amazon 价格：告别脱发的零代码神操作，亚马逊卖家面临激烈市场价格竞争，2025 年 38% 的品类日调价 2-5 次，BuyBox 易主频繁。人工监控成本高，每 30 分钟刷新需 3 人轮班，月支约 1.5 万元，还存在数据延迟问题，错过降价黄金时段会导致单日 GMV 损失 7-12%。而 Bright Data 可实现零代码监控亚马逊价格，为卖家解决上述痛点，避免人力消耗与收益损失。
推荐｜23个Python爬虫开源项目代码：爬取微信、淘宝、豆瓣、知乎、微博等
m0_62283350的博客
08-07 1820
今天为大家整理了23个Python爬虫项目。整理的原因是，爬虫入门简单快速，也非常适合新入门的小伙伴培养信心。所有链接指向GitHub。
Python应用：什么是爬虫？
经年藏殊的博客
07-12 5434
什么是爬虫，以及爬虫的善恶分析，对爬虫君子协议的介绍
Selenium爬虫实践：ajax请求抓包
bigcarp的专栏
03-22 2389
Selenium爬虫实践：ajax请求抓包、浏览器退出 zz:https://segmentfault.com/a/1190000039178953 前言 最近在搞公司内部系统，累的一批，需要从另一个内部系统导出数据存到数据库做分析，有大量的数据采集工作，又没办法去直接拿到那个系统的接口，太难了，只能爬虫，但是cookie还经常失效，为了不每次登录失效就来找我重新注入Cookie，我写了一个手机版的网页，用来控制后台的selenium自动登录，截取token和cookie。 ajax请求抓.
Python实习模拟面试之抓包与爬虫：从网络协议到反爬策略
吾为热爱计科，致力于知识分享的践行者，此博客是我在这条道路上留下的足迹。
08-09 2193
在数据驱动的时代，网络爬虫已成为获取互联网信息的重要手段。作为Python方向的实习生，掌握抓包分析与爬虫开发技能，不仅能体现你对网络协议和编程实践的深刻理解，更是进入数据分析、自动化测试、安全研究等领域的敲门砖。本篇博客通过一场高度还原的模拟面试，带你深入“抓包与爬虫”这一技术核心。采用“面试官提问 + 候选人专业回答”的对话形式，系统解析从HTTP协议基础、抓包工具使用、到Scrapy框架实践与反爬策略的完整知识链，助你在面试中展现扎实的技术功底。最后，请你总结一下，掌握抓包与爬虫技术的核心是什么？
PHP抓虫助手：监控搜索引擎爬虫行为的轻量级工具
抓虫助手 v1.0 是一款专为 PHP 网站系统设计的轻量级爬虫监控工具，其核心功能是记录搜索引擎爬虫（如百度、谷歌、必应等）对网站页面的访问行为，帮助网站管理员或 SEO 优化人员分析搜索引擎蜘蛛的抓取频率、路径、...
基于PHP的抓虫助手 搜索引擎爬虫监控助手.zip
10-10
【标题】"基于PHP的抓虫助手 搜索引擎爬虫监控助手.zip" 指的是一款使用PHP语言开发的工具，旨在帮助用户监控和管理搜索引擎爬虫的行为。在这个项目中，开发者利用PHP的网络请求和数据解析能力，构建了一个能够追踪...
幽冥大陆(五十三)人工智能开发语言选型指南——东方仙盟筑基期
cybersnow精通 28 门计算机语言，凭借其超凡的技术能力，成功开发过上万个应用，广泛涉及政府、商业、个人等众多领域，甚至在检察院、环保局、公安局等专业场景中也大放异彩。不仅熟练掌握单片机和物联网开发，在软件架构设计方面更是独树一帜，自创了跨平台软件
12-18 498
在人工智能项目中，开发语言的选择并非取决于语言本身的 “优劣”，而是的综合考量。本文结合服务器端、客户端、轻量化设备、特种场景等不同维度，对比 Python、C#、C 语言、Go、Rust、Android（Kotlin/Java）的适配性，给出针对性选型建议。
非线性滤波——基于EKF的INS/GPS松组合算法的研究（直接法|EKF|欧拉角）
tsuibeyond的博客
12-18 5270
由于大多数的INS/GPS组合导航算法模型都是基于非线性模型，如何有效的融合INS与GPS的测量信息来对当前载体的位置、速度、姿态等信息进行估计成为一个被长期研究的课题。本篇博客试图记录一下使用直接法EKF算法实现INS/GPS松组合的过程，姿态角以欧拉角表示。
QtWeatherApp - 简单天气预报软件(C++ Qt6)(附源码)
sweetikelike的博客
12-18 568
摘要：QtWeatherApp 是一个基于 Qt 6 和 C++ 开发的桌面天气预报应用。该软件通过 OpenWeatherMap Geocoding API 获取城市经纬度，再调用 Open-Meteo 免费天气 API 查询当前天气和7天预报。核心功能包括：支持中英文城市查询、显示温度及天气描述、纯 C++ 实现 Qt 网络请求和 JSON 解析。项目采用模块化设计，包含网络请求、数据处理和 UI 交互组件，可作为学习 Qt 开发的参考案例。软件跨平台支持 Windows/macOS/Linux，源码已
传值还是传引用？c++，python对比
最新发布
ULTRAmanTAROACE的博客
12-18 350
操作PythonJavaC++传参（基本/不可变）引用（表现如值）值（primitive） / 引用副本（对象）值（拷贝）传参（容器/可变）引用（共享对象）引用副本（可修改内容）值（拷贝整个容器，除非用返回值返回对象引用primitive：值；对象：引用返回值（通常移动或 RVO 优化）赋值 a = ba 绑定到 b 所指对象primitive：值拷贝；对象：引用拷贝深拷贝（调用 operator=）push 到容器存储对象引用存储对象引用拷贝或移动元素（值语义）
如何快速在 VS2026 上使用 C++ 模块 — 完整上手指南
charlie114514191的博客
12-15 819
本文介绍了在VS2026中使用C++20模块特性的完整指南。文章首先阐述了模块的优势，如增量编译和更健壮的导出机制。接着提供了使用前提条件，包括VS2026的安装和C++标准设置。通过一个包含模块接口单元(math.ixx)和主程序(main.cpp)的最小示例，详细说明了模块的创建和使用方法。最后，文章指导读者在VS2026 IDE中配置项目、添加模块文件并设置语言标准，以顺利构建运行模块化程序。文末还提供了微软官方的相关参考资料。
【C++】--AVL树的认识和实现
2302_81083101的博客
12-14 877
前面我们学习了二叉搜索树，其在一般情况下，对数据的查找的效率为O(logN)，但是在极端的情况下，其时间复杂度会达到O(n)。如下：右边的单支或者接近单支的情况就会导致查找的效率变得很低。所以后来又发明了AVL树，AVL树是两个前苏联科学家在1962年发表的。其概念如下：AVL树最先发明自平衡二叉查找树，其是一棵空树，或者具有以下性质的二叉树，它的左右子树也都是AVL树，然后左右子树的高度差不能超过1。AVL树是一棵高度平衡二叉树，其通过控制高度差去控制平衡。
基于大衍数构造的稀疏校验矩阵LDPC误码率matlab仿真,对比不同译码迭代次数,码率以及码长
fpga/matlab/simulink算法仿真工程
12-14 421
本文提出了一种基于大衍数列构造LDPC校验矩阵的新方法。该方法利用大衍数列的周期性和单调递增特性，设计具有准循环结构的稀疏校验矩阵，有效避免了四环问题并减少存储空间需求。文章详细阐述了算法原理，包括参数初始化、大衍数序列生成、位置映射规则和矩阵验证流程。MATLAB仿真测试表明，该方法能实现可靠的LDPC编码性能，误码率随信噪比提升显著降低。完整的算法代码可通过指定方式获取。该方案兼具理论创新性和工程实用性，为LDPC码构造提供了新的设计思路。
Lua vs C++：核心设计哲学差异——从“系统基石”到“灵活工具”的思维碰撞
羑悻的博客.
12-17 2881
它的每一个特性都需要开发者明确声明意图，编译器会尽可能在编译期捕捉错误（如类型不匹配、未初始化的变量），但对运行时的行为（如内存泄漏、多线程竞争）则交给开发者自己管理。理解两者的设计哲学差异，不仅能帮助你在技术选型时做出更明智的决策，还能让你在不同语言的协作中游刃有余——毕竟，真正的顶尖开发者，从来不是局限于某一种语言，而是能根据问题场景选择最合适的工具。Lua的存在意义是作为“胶水语言”，让主程序（通常是C/C++开发的系统）能够通过脚本快速实现业务逻辑的迭代，而无需重新编译主程序。
评论 8
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值