C/C++ PrintStackTrace（打印调试跟踪 / 捕获打印堆栈）Linux

最新推荐文章于 2025-04-30 09:24:26 发布

liulilittle

最新推荐文章于 2025-04-30 09:24:26 发布

阅读量2.8k

点赞数

分类专栏： C/C++ Src-shared

本文链接：https://blog.youkuaiyun.com/liulilittle/article/details/105594656

版权

C/C++ 同时被 2 个专栏收录

289 篇文章

订阅专栏

Src-shared

17 篇文章

订阅专栏

本文详细介绍了如何在C++中实现堆栈跟踪打印功能。通过使用backtrace和backtrace_symbols函数，结合cxa_demangle进行符号解析，能够获取并打印出详细的堆栈跟踪信息，帮助开发者在遇到程序崩溃时快速定位问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

usage：

PrintStackTrace();

impl：

#define PrintStackTrace()                                               \
{                                                                       \
    static const int MAX_STACK_TRACE_CONTENT_SIZE = 65535;              \
                                                                        \
    char __internal_szstacktrace_buffer[MAX_STACK_TRACE_CONTENT_SIZE];  \
    CaptureStackTrace(__internal_szstacktrace_buffer,                   \
        MAX_STACK_TRACE_CONTENT_SIZE);                                  \
                                                                        \
    if (*__internal_szstacktrace_buffer != '\x0')                       \
    {                                                                   \
        printf(__internal_szstacktrace_buffer);                         \
        LOG_ERROR("\n%s\n\n", __internal_szstacktrace_buffer);          \
    }                                                                   \
}

#include <stdlib.h>
#include <unistd.h>
#include <cxxabi.h> 
#include <execinfo.h>

int CaptureStackTrace(char* szStackTrace, int nStackTraceSize)
{
    if (NULL == szStackTrace)
    {
        return ~0;
    }

    *szStackTrace = '\x0';

    if (nStackTraceSize <= 0)
    {
        return 0;
    }

    static const int MAX_STACK_TRACE_SIZE = 100;
    static const int MAX_STACK_TRACE_STRING = 260;

    void* pStackFrame[MAX_STACK_TRACE_SIZE];
    int nptrs = backtrace(pStackFrame, MAX_STACK_TRACE_SIZE);

    char** pszStackBuffer = backtrace_symbols(pStackFrame, nptrs);
    if (NULL == pszStackBuffer)
    {
        return 0;
    }

    for (int iStackFrameIndex = 1; iStackFrameIndex < nptrs; iStackFrameIndex++)
    {
        char szStackString[MAX_STACK_TRACE_STRING];
        memcpy(szStackString, pszStackBuffer[iStackFrameIndex], MAX_STACK_TRACE_STRING);

        int iStackStringLength = (int)::strlen(szStackString);
        if (iStackStringLength <= 0)
        {
            continue;
        }

        char* pProcNameKey = (char*)::strchr(szStackString, '(');
        *pProcNameKey++ = '\x0';

        char* pProcEipAddr = (char*)::strchr(pProcNameKey, ')');
        *pProcEipAddr++ = '\x0';

        char szStackTempText[MAX_STACK_TRACE_STRING];
        if (*pProcNameKey == '\x0')
        {
            sprintf(szStackTempText, "%s%s", szStackString, pProcEipAddr);
        }
        else
        {
            char* pSymbolName = (char*)abi::__cxa_demangle(pProcNameKey, NULL, NULL, NULL);
            if (NULL == pSymbolName)
            {
                char szSymbolNameTemp[MAX_STACK_TRACE_STRING];
                szSymbolNameTemp[0] = '\x0';

                strcpy(szStackTempText, pProcNameKey);

                char* pProcName = szStackTempText;
                char* pProcAddr = (char*)strchr(pProcName, '+');
                *pProcAddr++ = '\x0';

                pSymbolName = (char*)abi::__cxa_demangle(pProcName, NULL, NULL, NULL);
                if (NULL == pSymbolName)
                {
                    pSymbolName = pProcName;
                }

                strcat(szSymbolNameTemp, pSymbolName);

                if (NULL != pProcAddr && *pProcAddr != '\x0')
                {
                    strcat(szSymbolNameTemp, "+");
                    strcat(szSymbolNameTemp, pProcAddr);
                }

                pSymbolName = szSymbolNameTemp;
            }

            sprintf(szStackTempText, "%s(%s)%s\r\n", szStackString, pSymbolName, pProcEipAddr);
        }

        strncat(szStackTrace, szStackTempText, (size_t)nStackTraceSize);
    }

    return nptrs;
}