Linux C/C++ 对于SIGBUS、SIGSEGV等崩溃异常捕获实现

最新推荐文章于 2024-08-19 20:50:22 发布
最新推荐文章于 2024-08-19 20:50:22 发布
阅读量5.7k 收藏 6
点赞数
分类专栏： C/C++ 文章标签： linux c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/122728497
版权

前段时间我们发表过类似得 Try-Catch 实现，但是该实现本身是存在局限性的，因为它们不能无视 SIGSEGV，SIGSYS，SIGTRAP等崩溃信号，对于某些3RD代码根本无法处理（这些代码没有源代码只有库，总不可能去静态反编译在改汇编）或者是短时间无法解决得内存BUG、例如毫无问题得代码在ARM平台会发生结构内存对齐问题（SIGBUS）导致强行崩溃（仅限于恶意崩溃，即运行相同代码+结构上万次以后才会发生SIGBUS提示内存对齐故障）别认为不可能，这在ARM上面存在潜在发生得可能性，解决办法查汇编查代码对所有的结构进行对齐检查，等等。

本文代码对于下文链接得扩展：

C/C++ 11 try-catch-finally 扩展（函数式）_liulilittle的博客-CSDN博客_c++ finally

假设...我们希望：类似以下的代码不要导致程序停止工作那么应该怎么处理？

int64_t llPtr = 0;

char* byPtr = (char*)llPtr;

*byPtr = rand() & 0xff;

... ...

printf("%s\n", "OK!");

我们知道上述代码务必会遭遇 “SIGSEGV” 导致崩溃并且产生 dump 文件/信息（若设置）那么我们不希望这里出现故障应该怎么做？

SIGSEGV 是可以被认为捕获得，有一个偷懒得宏定义叫做 SIG_IGN（忽略信号）但要注意，它的确忽略信号，确保程序不会因为崩溃信号停止工作，但这是有限度的，类似 SIGSEGV、SIGBUS 等信号是无效的，不要考虑这种没有意义得东西，就算要放弃某个信号也不应该是这么粗放式得操作，SIG_IGN 这类型仅适用于程序主动得 raise 得崩溃信号，比如：SIG_PIPE。

OK，那么可以适用最新改进得：“Try-Catch-Finally” 进行处理，但发生异常时可能潜在导致内存泄漏问题。

Try([] {

int64_t llPtr = 0;

char* byPtr = (char*)llPtr;

*byPtr = rand() & 0xff;

}).Catch<std::exception>([] (std::exception& e) {

printf("%s\n", "Error!");

});

printf("%s\n", "OK!");

以上代码是可以正确执行到 OK！部分，并且不会发生内存泄漏问题，但一旦我们在 lambda 内操作关于内存相关的东西就有可能发生异常，比如在函数内复制了一个 shared_ptr 并且在析构以前出现异常，那么 shared_ptr 得引用就无法在减少导致内存资源泄露，那么类似得好办法是不要使用 shared_ptr，或者在可以确定不会发生异常得情况下使用，如果你真不确定还非得头铁用得话，有个办法：weak_ptr 可能很适合您。

潜在发生异常得 lambda 函数是可以捕获类似 shared_ptr 之类的东西，它们并不会引起不能调用捕获 shared_ptr 得析构函数，所以是是线上内存安全的，但是 lambda 内部操作不是内存安全的，这个必须要说清楚！

Try.h

 #pragma once 

#include <stdio.h>  
#include <stdlib.h>  
#include <signal.h>  
#include <setjmp.h>  
#include <unistd.h> 
#include <memory>
#include <exception>
#include <mutex>
#include <unordered_map>

#ifndef MAX_STACK_FRAME
#define MAX_STACK_FRAME 10
#endif

namespace My {
    class Try {
    private:
        typedef sigjmp_buf                                      Context;
        struct Stack {
        private:
            mutable std::shared_ptr<Context>                    rbp;
            mutable Context*                                    rsp;

        public:
            Stack();
            void                                                New() const;
            void                                                Release() const;
            inline Context*                                     Ptr() const {
                return this->rbp.get();
            }
            inline Context*                                     Push() const {
                Context* max = this->rbp.get() + MAX_STACK_FRAME;
                if (this->rsp >= max) {
                    return NULL;
                }
                return this->rsp++;
            }
            inline Context*                                     Pop() const {
                if (this->rsp <= this->rbp.get()) {
                    return NULL;
                }
                return --this->rsp;
            }
            inline Context*                                     Peek() const {
                Context* max = this->rbp.get() + MAX_STACK_FRAME;
                if (this->rsp > max || this->rsp <= this->rbp.get()) {
                    return NULL;
                }
                return this->rsp - 1;
            }
        };
        typedef std::unordered_map<int, Stack>                  StackTable;
        friend class                                            Hosting;
        friend class                                            __TRY_SEH_SIGNAL__;

    public:
        inline Try(const std::function<void()>& block)
            : ___try(block) {
            if (!block) {
                throw std::runtime_error("The block part of the try is not allowed to be Null References");
            }
        }
        inline ~Try() {
            ___try = NULL;
            ___catch = NULL;
            ___finally = NULL;
        }

    public:
        template<typename TException>
        inline Try&                                             Catch() const {
            return Catch<TException>([](TException& e) {});
        }
        template<typename TException>
        inline Try&                                             Catch(const std::function<void(TException& e)>& block) const {
            return Catch<TException>(block, NULL);
        }
        template<typename TException>
        inline Try&                                             Catch(const std::function<void(TException& e)>& block, const std::function<bool(TException& e)>& when) const {
            if (!block) {
                throw std::runtime_error("The block part of the try-catch is not allowed to be Null References");
            }
            std::function<bool(std::exception*)> previous = ___catch;
            ___catch = [block, previous, when](std::exception* e) {
                if (previous) {
                    if (previous(e)) {
                        return true;
                    }
                }
                TException* exception = dynamic_cast<TException*>(e);
                if (!exception) {
                    return false;
                }
                if (when) {
                    if (!when(*exception)) {
                        return false;
                    }
                }
                if (block) {
                    block(*exception);
                }
                return true;
            };
            return const_cast<Try&>(*this);
        }
        inline Try&                                             Finally(const std::function<void()>& block) const {
            ___finally = block;
            return const_cast<Try&>(*this);
        }
        inline void                                             Invoke() const {
            Context* stack_context = Try::PushContext();
            std::exception* stack_exception = NULL;
            try {
                if (!stack_context) {
                    ___try();
                }
                else {
                    if (sigsetjmp(*stack_context, 1) == 0) {
                        ___try();
                    }
                    else {
                        stack_exception = &Try::___exception;
                        if (___catch) {
                            if (___catch(stack_exception)) {
                                stack_exception = NULL;
                            }
                        }
                    }
                }
            }
            catch (std::exception& throwable) {
                stack_exception = &throwable;
                if (___catch) {
                    if (___catch(stack_exception)) {
                        stack_exception = NULL;
                    }
                }
            }
            catch (...) {
                stack_exception = &Try::___exception;
                if (___catch) {
                    if (___catch(stack_exception)) {
                        stack_exception = NULL;
                    }
                }
            }
            if (___finally) {
                ___finally();
            }
            if (stack_context) {
                Try::PopContext();
            }
            if (stack_exception) {
                throw *stack_exception;
            }
        }
        #ifndef ANDROID
        static void                                             PrintStackTrace();
        #endif

    private:
        static Context*                                         PushContext();
        static Context*                                         PopContext();
        static Context*                                         PeekContext();
        static void                                             AllocStack(bool important);
        static void                                             ReleaseStack();

    private:
        mutable std::function<void()>                           ___try;
        mutable std::function<bool(std::exception*)>            ___catch;
        mutable std::function<void()>                           ___finally;
        static std::runtime_error                               ___exception;
        static std::mutex                                       ___syncobj;
        static StackTable                                       ___stack;
        static struct sigaction                                 ___osas[15]; 
    };
}

Try.cpp

#include <stdio.h>
#include <signal.h>
#include <limits.h>
#include <sys/file.h>
#ifndef ANDROID
#include <unwind.h>
#include <execinfo.h>
#include <sys/resource.h>
#endif
#include <My/Try.h>
#include <My/Environment.h>

#ifndef ANDROID
#define MAX_BACKTRACE_SIZE 100
#endif

namespace My {
    class __TRY_SEH_SIGNAL__ {
    public:
        inline __TRY_SEH_SIGNAL__() {
            memset(Try::___osas, 0, sizeof(Try::___osas));
            /*retrieve old and set new handlers*/
            /*restore prevouis signal actions*/
            #ifdef ANDROID
            Watch(35,        0); // FDSCAN(SI_QUEUE)
            #endif
            Watch(SIGBUS,    1);
            Watch(SIGPIPE,   2);
            Watch(SIGFPE,    3);
            Watch(SIGSEGV,   4);
            Watch(SIGILL,    5);
            Watch(SIGTRAP,   6);
            Watch(SIGSYS,    7);
            Watch(SIGQUIT,   8);
            Watch(SIGIOT,    9);
            Watch(SIGUSR1,   10);
            Watch(SIGUSR2,   11);
            Watch(SIGXCPU,   12);
            Watch(SIGXFSZ,   13);
            Watch(SIGSTKFLT, 14);
        }
        inline ~__TRY_SEH_SIGNAL__() {
            struct sigaction* osas = Try::___osas;

            /*restore prevouis signal actions*/
            #ifdef ANDROID
            Unwatch(35,        0); // FDSCAN(SI_QUEUE)
            #endif
            Unwatch(SIGBUS,    1);
            Unwatch(SIGPIPE,   2);
            Unwatch(SIGFPE,    3);
            Unwatch(SIGSEGV,   4);
            Unwatch(SIGILL,    5);
            Unwatch(SIGTRAP,   6);
            Unwatch(SIGSYS,    7);
            Unwatch(SIGQUIT,   8);
            Unwatch(SIGIOT,    9);
            Unwatch(SIGUSR1,   10);
            Unwatch(SIGUSR2,   11);
            Unwatch(SIGXCPU,   12);
            Unwatch(SIGXFSZ,   13);
            Unwatch(SIGSTKFLT, 14);
        }
        
    public:
        inline int                      Watch(int signo, int index) {
            struct sigaction sa;
            struct sigaction* osas = Try::___osas;
            memset(&sa, 0, sizeof(sa));

            /*init new handler struct*/  
            sa.sa_handler = [] (int signo) {
                Try::Context* context = Try::PeekContext();
                if (context) {
                    siglongjmp(*context, 1);
                } else {
                    #ifndef ANDROID
                    Try::PrintStackTrace();
                    #endif
                    signal(signo, SIG_DFL);
                    raise(signo);
                }
            };
            sigemptyset(&sa.sa_mask);  
            sa.sa_flags = 0;
            
            return sigaction(signo, &sa, &osas[index]);
        }
        inline int                      Unwatch(int signo, int index) {
            struct sigaction* osas = Try::___osas;
            return sigaction(signo, &osas[index], NULL);
        }
    }                                   g__TRY_SEH_SIGNAL__;
    std::unordered_map<int, Try::Stack> Try::___stack;
    std::mutex                          Try::___syncobj;
    std::runtime_error                  Try::___exception("Received an error signal thrown by the system or application during code execution.");
    struct sigaction                    Try::___osas[15];

    Try::Stack::Stack() 
        : rbp(NULL)
        , rsp(NULL) {
        this->New();
    }

    void Try::Stack::New() const {
        this->rbp = make_shared_alloc<Context>(MAX_STACK_FRAME);
        this->rsp = this->rbp.get();
    }

    void Try::Stack::Release() const {
        this->rbp = NULL;
        this->rsp = NULL;
    }

    Try::Context* Try::PushContext() {
        std::lock_guard<std::mutex> scope(Try::___syncobj);
        return Try::___stack[Hosting::GetCurrentThreadId()].Push();
    }

    Try::Context* Try::PopContext() {
        std::lock_guard<std::mutex> scope(Try::___syncobj);
        return Try::___stack[Hosting::GetCurrentThreadId()].Pop();
    }

    Try::Context* Try::PeekContext() {
        std::lock_guard<std::mutex> scope(Try::___syncobj);
        return Try::___stack[Hosting::GetCurrentThreadId()].Peek();
    }

    void Try::AllocStack(bool important) {
        std::lock_guard<std::mutex> scope(Try::___syncobj);
        int id = Hosting::GetCurrentThreadId();

        StackTable::iterator kv = Try::___stack.find(id);
        if (kv != Try::___stack.end()) {
            const Stack& stack = kv->second;
            if (important || !stack.Ptr()) {
                stack.New();
            }
        }
        else {
            Stack stack;
            Try::___stack.insert(std::make_pair(id, stack));
        }
    }

    void Try::ReleaseStack() {
        std::lock_guard<std::mutex> scope(Try::___syncobj);
        StackTable::iterator kv = Try::___stack.find(Hosting::GetCurrentThreadId());
        if (kv != Try::___stack.end()) {
            const Stack& stack = kv->second;
            stack.Release();
            Try::___stack.erase(kv);
        }
    }

    #ifndef ANDROID
    void Try::PrintStackTrace() {
        char maps_string[1000] = "0";
        sprintf(maps_string, "cat /proc/%d/maps", getpid());
        system(maps_string); 
        {
            printf("\nStack Addresses:\n");
            _Unwind_Backtrace([](struct _Unwind_Context* context, void* arg) -> _Unwind_Reason_Code {
                uintptr_t pc = _Unwind_GetIP(context);
                if (pc) {
                    printf(" at pc:0x%llx\n", (unsigned long long)pc);
                }
                return _URC_NO_REASON;
            }, 0); // _Unwind_Reason_Code rc, rc == _URC_END_OF_STACK ? 0 : -1;
        }
        void* stack_frames[MAX_BACKTRACE_SIZE];
        int nptrs = backtrace(stack_frames, MAX_BACKTRACE_SIZE);
        {
            printf("\nStack Frame: %d\n", nptrs);
        }
        char** frame_strings = backtrace_symbols(stack_frames, nptrs);
        if (NULL != frame_strings) {
           for (int i = 0; i < nptrs; i++) {
                printf(" at [%02d] %s\n", i, frame_strings[i]);
           }
           free(frame_strings);
        }
    }
    #endif
}

liulilittle
关注
专栏目录
【我的C/C++语言学习进阶之旅】NDK开发运行的时候出现错误signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x940a2e48
字节卷动
09-29 1544
信号(signal)机制它其实是进程间通信的一种方式。在处理ndk crash日志的时候可以大概理解为错误码,它描述了错误的大概原因。信号码值描述SIGILL4非法指令，例如损坏的可执行文件或代码区损坏SIGABRT6通过C函数abort()发送；为assert()使用SIGBUS7不存在的物理地址，更多为硬件或系统引起SIGFPE8浮点数运算错误，如除0操作SIGKILL9迅速完全终止进程；不能被捕获SIGSEGV11段地址错误，例如空指针、野指针、数组越界等。
linux信号（signal) 机制分析
江南又一春
03-04 422
1 信号本质 软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。在软件层次上是对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是进程间通信机制中唯一的异步通信机制，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件...
X86 Linux 下 SIGBUS 总结
weixin_34279061的博客
06-05 839
SIGBUS 在 x86 Linux 上并不多见，但一旦出现，其调用堆栈常常让人摸不着头脑，加之信号问题各平台系统间差异较大，更让人难以理清，这里稍微总结一下 x86 Linux 上大概有哪些情形会触发 BUS ERROR. 文件映射访问异常 这是 SIGBUS 在用户态最为常见的场景，也最容易触发，通常来说根本原因都是进程 mmap 了一个文件后，另外的进程把这个文件截断了，导致 mmap 出来...
【unix高级编程系列】信号
最新发布
点滴路程
08-19 777
本文详细介绍了Linux信号的概念、处理方式、常见信号的用途以及信号处理函数的使用。希望能给您带来帮助若我的内容对您有所帮助，还请关注我的公众号。不定期分享干活,剖析案例，也可以一起讨论分享。踩完您工作中的所有坑并分享给您，让你的工作无bug，人生尽是坦途。
linux C/C++ 捕获 SIGSEGV 段错误信号
a1367666195的博客
03-22 455
崩溃是常见现象，有时候，我们希望程序在崩溃的时候，先做点其他操作再崩溃，比如记录崩溃时刻的堆栈信息，或是提前释放一些硬件资源等等，那么就需要让程序捕获错误信号。信号，主要由访问空指针、内存访问越界、访问已释放的内存等原因导致。
C++ SIGSEGV报错
yi__cao的博客
09-03 1177
今天写代码碰到了一个特别离谱的问题，程序运行着突然就崩溃了。 最后原因是因为在之前调用的函数中出现了数组越界的情况，但是当时并没有报错，程序仍然正常运行。 直到我调用另一个函数时，程序才莫名其妙崩溃。 在今后c++的编写中一定要注意数组越界问题，这会引发莫名的错误。 ...
C++ :Signal: SIGSEGV (Segmentation fault) ,深拷贝
热门推荐
superSmart_Dong的博客
08-18 2万+
C++在运行时出现Signal: SIGSEGV (Segmentation fault) 问题，通常是访问了系统给这个程序所分配以外的内存空间。从而出现段错误，经常在使用指针时会出现。 例如 bounds_ =(int *)malloc(2 * sizeof(int)) bonuds_[0]= 0 ; bonuns_[1]= 1 ; base = bound; cout<<base[0]; // 0 free(bound); cout<<base[0]; //S.
linux SIGSEGV信号
mayue_web的博客
04-20 2487
文章目录关于SIGSEGV错误及处理方法 https://blog.csdn.net/brace/article/details/1102422 关于SIGSEGV错误及处理方法 今天编程遇到了SIGSEGV错误（段错误），比较困惑，所以找了些资料，总结一下： （1）官方说法是： SIGSEGV --- Segment Fault. The possible cases of your encountering this error are: 1.buffer overflow --- usually
【C/C++ Windows编程】Windows系统消息、Qt消息事件、linux下kill信号
qq_58397358的博客
09-07 2536
Windows中有一个系统消息队列，对于每一个正在执行的Windows应用程序，系统为其建立一个“消息队列”，即应用程序消息队列，用来存放该程序可能创建的各种窗口的消息。应用程序中含有一段称作“消息循环”的代码，用来从消息队列中检索这些消息并把它们分发到相应的窗口函数中。在windows中，“一切皆为窗口”。虽然不是很贴切，但是说明了窗口的普遍性和其重要性。比如，你现在看到的QQ聊天窗口，就是由多个窗口组成的！Windows程序是由一系列的窗口构成的，每个窗口都有自己的窗口过程。
【C/C++】C语言signal信号|软中断信号|程序捕获Ctrl+C 信号
小鱼菜鸟的博客
08-13 859
目录 程序捕获Ctrl+C 信号 软中断信号 signal(SIGCHLD, SIG_IGN) SIGCHLD信号 SIG_ING 使用signal(SIGCHLD, SIG_IGN)处理僵尸进程 程序捕获Ctrl+C 信号 在Linux下面写一个程序，如果程序中出现死循环的话，我们就应该在键盘上按Ctrl+C来...
Ubuntu C++ 使用gdb+core分析软件崩溃原因
yao51011010的专栏
03-13 1178
core 叫做核心转储,它是进程运行过程中突然崩溃那一刻的内存快照.操作系统在程序发生异常并且异常 在进程内部又没有被捕获的情况下，会把进程此刻内存、寄存器状态、运行堆栈等信息转储保存在一个core文件里.
Android native 崩溃信息捕获实践
Jekton
04-06 2749
本篇是 bugly 一篇关于 native crash 捕获的文章的练习。由于他文章中已经给出了相关的大部分知识点，这里我就仅仅补充一些细节，并给出一个完整的 demo
linux C++下捕获崩溃日志
twtydgo的专栏
02-05 2343
#include #include #include #include #include #include #include const int MAX_STACK_FRAMES = 128; void sig_crash(int sig) {     FILE* fd;     struct stat buf;     stat("./crash.log",
C++ SIGSEGV check list
fyfcauc的专栏
04-18 1995
C++丢了很长时间了，没想到还有捡回来的一天，各种不适应，尤其是指针相关的，SIGSEGV这几天真没少见，总结下自己遇到的SIGSEGV case，下面这个可以作为一个check-list: null指针解引用，这个就不说了，解引用前自己做好预防。 要求返回值的函数实现时没有返回值，按理说IDE会提示，但是目前看AS很多时候是不会提示的。 使用RAII对象管理内存时，因为临时对象析构的原因导致RA
C++报错signal SIGSEGV, Segmentation fault
weixin_45105510的博客
07-19 2781
解决signal SIGSEGV, Segmentation fault
内存访问错误造成Segmentation fault （SIGSEGV）
Fan0920的专栏
06-11 1万+
　linux下程序对SIGSEGV信号的默认处理方式是产生coredump并终止程序，可以参考man 7 signal Signal Value Action Comment ────────────────────────────────────────────────────────────────────── SIGHUP...
linux SIGSEGV 信号捕捉，保证发生段错误后程序不崩溃
chenzhjlf的专栏
05-05 2206
在linux中编程的时候 有时候 try catch 可能满足不了我们的需求。因为碰到类似数组越界 ，非法内存访问之类的 ，这样的错误无法捕获。下面我们介绍一种使用捕获信号实现的异常 用来保证诸如段错误之类的错误发生时程序不会崩溃，而是跳过代码继续执行。首先我们来看看发生段错误之后系统的处理。 发生段错误后系统会抛出 SIGSEGV 信号 ，之后 调用默认的信号处理函数 ，产生core文件 ，然后关闭程序 。 那有没有一种办法可以保证程序不会死掉呢，当然是...
Linux系统中段错误信号sigsegv的捕获
qq_40464599的博客
04-02 740
但是，在某些情况下，我们希望能够捕获这个信号，并进行一些特定的处理，比如打印出错信息、记录日志或者进行资源清理等，而不是让程序立即退出。在上述代码中，为了简化，我们没有包含这部分内容，但在实际开发过程中，这是非常重要的一步。的错误，例如，确保指针在使用前已经被正确初始化，数组访问不超过其边界等。在信号处理函数中，我们可以进行错误处理，比如打印相关信息或者清理资源。在Linux系统中，当程序试图访问它没有权限访问的内存区域时，操作系统会发送一个。在上面的代码中，我们使用。在实际的应用中，处理。
linux C++ 崩溃堆栈抓取全过程
weixin_41654661的博客
11-10 1343
它包括函数名，函数的偏移地址，和实际的返回地址。该函数用于获取当前线程的调用堆栈，获取的信息将会被存放在buffer中，它是一个指针列表。函数返回值是实际获取的指针个数，最大不超过size大小，在buffer中的指针实际是从堆栈中获取的返回地址，每一个堆栈框架有一个返回地址，注意某些编译器的。backtrace_symbols_fd与backtrace_symbols 函数具有相同的功能，不同的是它不会给调用者返回字符串数组，而是将结果写入文件描述符为fd的文件中，每个函数对应一行。
通过signal函数捕获SIGSEGV、SIGBUS等信号，避免程序崩溃。 使用errno变量来检查函数调用时是否出现错误。 使用setjmp和longjmp函数来处理异常怎么写
06-07
以下是三种方法的简单示例： 1. 通过signal函数捕获信号 ```c #include <signal.h> void signal_handler(int signal) { // 处理信号 } int main() { // 注册信号处理函数 signal(SIGSEGV, signal_handler); signal(SIGBUS, signal_handler); // 程序代码 // ... return 0; } ``` 2. 使用errno变量检查函数调用是否出错 ```c #include <stdio.h> #include <errno.h> int main() { FILE* fp = fopen("file.txt", "r"); if (fp == NULL) { printf("打开文件出错：%d\n", errno); } else { // 文件操作代码 // ... fclose(fp); } return 0; } ``` 3. 使用setjmp和longjmp函数处理异常 ```c #include <stdio.h> #include <setjmp.h> jmp_buf buf; void error_handler() { longjmp(buf, 1); } int main() { // 设置错误处理函数 if (setjmp(buf) != 0) { printf("出现错误\n"); return 1; } // 程序代码 // ... // 出现错误时调用错误处理函数 error_handler(); return 0; } ``` 需要注意的是，以上示例仅为演示用途，实际使用时需要根据具体情况进行修改和完善。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值