C++函数调用栈使用进阶

最新推荐文章于 2023-09-26 08:00:00 发布
最新推荐文章于 2023-09-26 08:00:00 发布
阅读量764 收藏
点赞数
分类专栏： # 04std_C++ # 01std_C # 03unix_c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/halazi100/article/details/118932936
版权
01std_C 同时被 3 个专栏收录
56 篇文章 3 订阅
订阅专栏
04std_C++
38 篇文章 0 订阅
订阅专栏
03unix_c
25 篇文章 0 订阅
订阅专栏

函数调用栈高级用法

当程序运行异常退出时自动打印当前的函数调用栈,便于分析定位问题；
设计思路：

  1. 设计一个C++类 CallStack, 该类封装函数调用栈相关信息的搜集与组装；
  2. 设计一个C函数 callstack_dump(), 该接口创建一个函数调用栈类实例对象并输出函数调用栈；
  3. 设计一个信号处理函数 signal_SEGV_handler(int)，该接口用于调用上一步的API；
  4. 使用上一步设计的函数，注册为信号处理函数；

模仿android封装一个callstack类

CallStack头文件

/*****************************************
 * Copyright (C) 2021 * Ltd. All rights reserved.
 *
 * File name   : CallStack.hpp
 * Created date: 2021-07-15 14:25:42
 * Description : 
 *
 *******************************************/

#ifndef __CALLSTACK_H__
#define __CALLSTACK_H__

#include <iostream>
#include <stdint.h>
#include <sys/types.h>

namespace DebugTrace {

class CallStack
{
public:
    enum {
        MAX_DEPTH = 31
    };

    CallStack();
    CallStack(const CallStack& rhs);
    ~CallStack();

    CallStack& operator = (const CallStack& rhs);

    bool operator == (const CallStack& rhs) const;
    bool operator != (const CallStack& rhs) const;
    bool operator < (const CallStack& rhs) const;
    bool operator >= (const CallStack& rhs) const;
    bool operator > (const CallStack& rhs) const;
    bool operator <= (const CallStack& rhs) const;

    const void* operator [] (int index) const;

    void clear();

    void update(int32_t ignoreDepth=0, int32_t maxDepth=MAX_DEPTH);

    // Dump a stack trace to the log
    void dump(const char* prefix = 0) const;
    std::string toString(const char* prefix = 0) const;

    size_t size() const { return mCount; }

private:
    std::string toStringSingleLevel(const char* prefix, int32_t level) const;

    size_t mCount;
    void * mStack[MAX_DEPTH];
}; // class CallStack

}; // namespace DebugTrace


#endif //__CALLSTACK_H__

CallStack实现

/*****************************************
 * Copyright (C) 2021 * Ltd. All rights reserved.
 * File name   : CallStack.cpp
 * Created date: 2021-07-15 14:28:35
 *******************************************/

#include <iostream>
#include <mutex>
#include <string>
#include <vector>
#include <map>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <unistd.h>
#include <sys/types.h>
#include <execinfo.h>
#include "CallStack.hpp"

#if HAVE_DLADDR
#include <dlfcn.h>
#endif

#if HAVE_CXXABI
#include <cxxabi.h>
#endif

namespace DebugTrace {

typedef struct {
    size_t count;
    size_t ignore;
    const void** addrs;
} stack_crawl_state_t;

/*****************************************************************************/

static const char *lookup_symbol(const void* addr, void **offset, char* name, size_t bufSize)
{
#if HAVE_DLADDR
    Dl_info info;
    void *dli_saddr;
    if (dladdr(addr, &info)) {
        strncpy(name, info.dli_fname, bufSize);
        dli_saddr = info.dli_saddr;
        *offset = info.dli_saddr;
        if ((unsigned long long)addr >= (unsigned long long)dli_saddr) {
            *offset = (void *)((unsigned long long)addr - (unsigned long long)dli_saddr);
        }
        return info.dli_sname;
    }
#endif
    return NULL;
}

static int32_t linux_gcc_demangler(const char *mangled_name, char *unmangled_name, size_t buffersize)
{
    size_t out_len = 0;
#if HAVE_CXXABI
    int status = 0;
    char *demangled = abi::__cxa_demangle(mangled_name, 0, &out_len, &status);
    if (status == 0) {
        // OK
        if (out_len < buffersize) {
            memcpy(unmangled_name, demangled, out_len);
        } else {
            out_len = 0;
        }
        free(demangled);
    } else {
        out_len = 0;
    }
#endif
    return out_len;
}

/*****************************************************************************/

class MapInfo
{
struct Maps_Info_St {
    struct Maps_Info_St *next;
    uint64_t start;
    uint64_t end;
    char name[];
}; //struct Maps_Info_St

const char *map_to_name(uint64_t pc, const char* def, uint64_t* start) {
    Maps_Info_St* mi = getMapInfoList();
    while (mi) {
        if ((pc >= mi->start) && (pc < mi->end)) {
            if (start) {
                *start = mi->start;
            }
            return mi->name;
        }
        mi = mi->next;
    }
    if (start) {
        *start = 0;
    }
    return def;
}

Maps_Info_St *parse_maps_line(char *line) {
    Maps_Info_St *mi = NULL;
    unsigned long long int start = 0;
    unsigned long long int end = 0;
    char name[128] = { 0 };
    char permissions[5];

    int len = strlen(line);
    if (len < 50) return NULL;

    //7fbec608b000-7fbec608c000 r-xp 00000000 08:11 11142411 /home/user/toolkit/c++/callstack/lib/libdebug/libdebug.so
    //6f000000-6f01e000 rwxp 00000000 00:0c 16389419   /system/lib/libcomposer.so
    if (sscanf(line, "%llx-%llx %4s %*x %*x:%*x %*d %127s",
                &start, &end, permissions, name) != 4) {
        return NULL;
    }

    if (permissions[2] != 'x') return NULL;
    // printf("len:%d permissions[2]:%c %s", len, permissions[2], line);

    mi = (Maps_Info_St*)malloc(sizeof(Maps_Info_St) + strlen(name));
    if (mi == NULL) return NULL;

    // mi->start = strtoull(line, 0, 16);
    // mi->end = strtoull(line + 9, 0, 16);
    // strcpy(mi->name, line + 49);
    mi->start = (uint64_t)start;
    mi->end = (uint64_t)end;
    strcpy(mi->name, name);

    // printf("0x%lx-0x%lx %s\n", mi->start, mi->end, mi->name);
    mi->next = 0;
    return mi;
}

Maps_Info_St* getMapInfoList() {
    //Mutex::Autolock _l(mLock);
    if (mMIlist != NULL) {
        return mMIlist;
    }

    char data[1024] = { 0 };
    FILE *fp = NULL;
    sprintf(data, "/proc/%d/maps", getpid());
    fp = fopen(data, "r");
    if (fp) {
        while (fgets(data, 1024, fp)) {
            Maps_Info_St *mi = parse_maps_line(data);
            if (mi) {
                mi->next = mMIlist;
                mMIlist = mi;
            }
        }
        fclose(fp);
    }
    return mMIlist;
}
Maps_Info_St*  mMIlist;
//Mutex          mLock;
static MapInfo sMapInfo;

public:
MapInfo()
    : mMIlist(0)
{
}

~MapInfo()
{
    while (mMIlist) {
        Maps_Info_St *next = mMIlist->next;
        free(mMIlist);
        mMIlist = next;
    }
}

static const char *mapAddressToName(const void* pc, const char* def,
        void const** start)
{
    uint64_t s;
    char const* name = sMapInfo.map_to_name(uint64_t(uintptr_t(pc)), def, &s);
    if (start) {
        *start = (void*)s;
    }
    return name;
}

}; //class MapInfo

/*****************************************************************************/

MapInfo MapInfo::sMapInfo;

/*****************************************************************************/

CallStack::CallStack()
    : mCount(0)
{
}

CallStack::CallStack(const CallStack& rhs)
    : mCount(rhs.mCount)
{
    if (mCount) {
        memcpy(mStack, rhs.mStack, mCount*sizeof(void*));
    }
}

CallStack::~CallStack()
{
}

CallStack& CallStack::operator = (const CallStack& rhs)
{
    mCount = rhs.mCount;
    if (mCount) {
        memcpy(mStack, rhs.mStack, mCount*sizeof(void*));
    }
    return *this;
}

bool CallStack::operator == (const CallStack& rhs) const
{
    if (mCount != rhs.mCount) {
        return false;
    }
    return !mCount || (memcmp(mStack, rhs.mStack, mCount*sizeof(void*)) == 0);
}

bool CallStack::operator != (const CallStack& rhs) const
{
    return !operator == (rhs);
}

bool CallStack::operator < (const CallStack& rhs) const
{
    if (mCount != rhs.mCount) {
        return mCount < rhs.mCount;
    }
    return memcmp(mStack, rhs.mStack, mCount*sizeof(void*)) < 0;
}

bool CallStack::operator >= (const CallStack& rhs) const
{
    return !operator < (rhs);
}

bool CallStack::operator > (const CallStack& rhs) const
{
    if (mCount != rhs.mCount) {
        return mCount > rhs.mCount;
    }
    return memcmp(mStack, rhs.mStack, mCount*sizeof(void*)) > 0;
}

bool CallStack::operator <= (const CallStack& rhs) const
{
    return !operator > (rhs);
}

const void* CallStack::operator [] (int index) const
{
    if (index >= int(mCount)) {
        return 0;
    }
    return mStack[index];
}

void CallStack::clear()
{
    mCount = 0;
}

void CallStack::update(int32_t ignoreDepth, int32_t maxDepth)
{
    if (maxDepth > MAX_DEPTH) {
        maxDepth = MAX_DEPTH;
    }
    if ((ignoreDepth < 0)) {
        ignoreDepth = 0;
    }
    if ((ignoreDepth > maxDepth)) {
        ignoreDepth = 0;
        maxDepth = 0;
        return;
    }
    mCount = backtrace(mStack, maxDepth);
    mCount -= ignoreDepth;
    int32_t i = 0;
    for (i = 0; i <= mCount; i++) {
        mStack[i] = mStack[i+ignoreDepth];
    }
    mStack[i] = 0;
}

// Return the stack frame name on the designated level
std::string CallStack::toStringSingleLevel(const char* prefix, int32_t level) const
{
    std::string res;
    char namebuf[1024];
    char tmp[256];
    char tmp1[32];
    char tmp2[32];
    void *offs;

    const void* ip = mStack[level];
    if (!ip) return res;

    if (prefix) res.append(prefix);
    snprintf(tmp1, 32, "#%02d  ", level);
    res.append(tmp1);

    // printf("ip: 0x%llx\n", (unsigned long long)ip);
    const char* name = lookup_symbol(ip, &offs, namebuf, sizeof(namebuf));
    if (name) {
        if (linux_gcc_demangler(name, tmp, 256) != 0) {
            name = tmp;
        }
        snprintf(tmp1, 32, "pc %p ", ip);
        snprintf(tmp2, 32, "+%p)", offs);
        res.append(tmp1);    //pc
        res.append(namebuf); //object name
        res.append(" (");
        res.append(name);    //symbol name
        res.append(tmp2);    //offs
    } else {
        void const* start = 0;
        name = MapInfo::mapAddressToName(ip, "<unknown>", &start);
        snprintf(tmp, 256, "pc 0x%08lx %s",
                long(uintptr_t(ip)-uintptr_t(start)), name);
        res.append(tmp);
    }
    res.append("\n");

    return res;
}

// Dump a stack trace to the log
void CallStack::dump(const char* prefix) const
{
    /*
     * Sending a single long log may be truncated since the stack levels can
     * get very deep. So we request function names of each frame individually.
     */
    for (int i = 0; i < int(mCount); i++) {
        printf("%s", toStringSingleLevel(prefix, i).c_str());
    }
}

// Return a string (possibly very long) containing the complete stack trace
std::string CallStack::toString(const char* prefix) const
{
    std::string res;

    for (int i = 0; i < int(mCount); i++) {
        res.append(toStringSingleLevel(prefix, i).c_str());
    }

    return res;
}

/*****************************************************************************/

}; // namespace DebugTrace

封装一个C函数

封装一个C接口 void callstack_dump(const char *prefix);
其中prefix用于指定每行输出的前缀；

此外还定义了一个 size_t callstack_strings(const char *prefix, char *const buf, const size_t max_size);
将输出信息放入用户传入的参数buf中, buf的大小为 max_size;

callstack_dump头文件

/*****************************************
 * Copyright (C) 2021 * Ltd. All rights reserved.
 *
 * File name   : libcallstack.h
 * Created date: 2021-07-16 09:10:18
 * Description : 
 *
 *******************************************/

//#pragma once
#ifndef __LIBCALLSTACK_H__
#define __LIBCALLSTACK_H__
#ifdef __cplusplus
extern "C"
{
#endif

void callstack_dump(const char *prefix);
size_t callstack_strings(const char *prefix, char *const buf, const size_t max_size);

#ifdef __cplusplus
}
#endif
#endif //__LIBCALLSTACK_H__

callstack_dump实现

/*****************************************
 * Copyright (C) 2021 * Ltd. All rights reserved.
 *
 * File name   : libcallstack.cpp
 * Created date: 2021-07-15 17:14:30
 * Description : 
 *
 *******************************************/

#include <iostream>
#include <string>
#include <vector>
#include <map>

#include "CallStack.hpp"
#include "libcallstack.h"

void callstack_dump(const char *prefix) { 
    DebugTrace::CallStack cs;
    cs.update(2, 32);
    cs.dump(prefix);
}

size_t callstack_strings(const char *prefix, char *const buf, const size_t max_size) {
    std::string res;
    DebugTrace::CallStack cs;
    cs.update(2, 32);
    res.assign(cs.toString(prefix).c_str(), max_size);
    std::copy(res.begin(), res.end(), buf);
    return res.size();
}

注意编译的时候注意定义-DHAVE_CXXABI -DHAVE_DLADDR并使用-ldl选项

给一个Makefile的例子

####################################################
# Created date: 2021-07-16 09:00:12
####################################################

#target: prerequisites 
#	command

DST = libcallstack.so
SRC = CallStack.cpp libcallstack.cpp
OBJS = $(patsubst %.cpp, %.o, $(SRC))
%.o: %.cpp
	$(XX) -o $@ -c -fPIC $< $(CXXFLAGS)

XX = g++
CXXFLAGS = -DHAVE_CXXABI -DHAVE_DLADDR

all: $(DST)
$(DST): $(OBJS)
	$(XX) -o $@ -shared $^ -ldl -rdynamic

.PHONY: clean
clean:
	-rm -v $(DST)
	-rm -v $(OBJS)

应用 callstack_dump()

在应用的地方定义一个信号处理函数

void signal_SEGV_handler(int signo) {
    std::cout << "signal_SEGV_handler received signal: " << signo << std::endl;
    callstack_dump("CALLSTACK_TEST_CPP: ");
    /* reset signal handle to default */
    signal(signo, SIG_DFL);
    /* will receive SIGSEGV again and exit app */
}

注册该信号处理函数

/* register handler of signal SIGSEGV */
signal(SIGSEGV, signal_SEGV_handler);

当应用异常崩溃的时候会收到信号SIGSEGV,然后会调用信号处理函数并打印调用栈

实例

比如程序异常crash并打印如下调用栈

$ ./callstack_test 
signal_SEGV_handler received signal: 11
CALLSTACK_TEST_CPP: #00  pc 0x55563954ae02 ./callstack_test (signal_SEGV_handler(int)+0x52)
CALLSTACK_TEST_CPP: #01  pc 0x0003f040 /lib/x86_64-linux-gnu/libc-2.27.so
CALLSTACK_TEST_CPP: #02  pc 0x7f635454d795 ./lib/libdebug/libdebug.so (libdebugfunccrash+0x1b)
CALLSTACK_TEST_CPP: #03  pc 0x7f635454d7b3 ./lib/libdebug/libdebug.so (libdebugfunc5+0x15)
CALLSTACK_TEST_CPP: #04  pc 0x7f635454d7cb ./lib/libdebug/libdebug.so (libdebugfunc4+0x15)
CALLSTACK_TEST_CPP: #05  pc 0x7f635454d7e3 ./lib/libdebug/libdebug.so (libdebugfunc3+0x15)
CALLSTACK_TEST_CPP: #06  pc 0x7f635454d7fb ./lib/libdebug/libdebug.so (libdebugfunc2+0x15)
CALLSTACK_TEST_CPP: #07  pc 0x7f635454d813 ./lib/libdebug/libdebug.so (libdebugfunc1+0x15)
CALLSTACK_TEST_CPP: #08  pc 0x7f635454d82b ./lib/libdebug/libdebug.so (libdebugfunc+0x15)
CALLSTACK_TEST_CPP: #09  pc 0x55563954ad67 ./callstack_test (func6(int, int)+0x1d)
CALLSTACK_TEST_CPP: #10  pc 0x55563954ad7d ./callstack_test (func5()+0x13)
CALLSTACK_TEST_CPP: #11  pc 0x55563954ad89 ./callstack_test (func4()+0x9)
CALLSTACK_TEST_CPP: #12  pc 0x55563954ad95 ./callstack_test (func3()+0x9)
CALLSTACK_TEST_CPP: #13  pc 0x55563954ada1 ./callstack_test (func2()+0x9)
CALLSTACK_TEST_CPP: #14  pc 0x55563954adad ./callstack_test (func1()+0x9)
CALLSTACK_TEST_CPP: #15  pc 0x55563954ae31 ./callstack_test (main+0x1d)
CALLSTACK_TEST_CPP: #16  pc 0x7f6353befbf7 /lib/x86_64-linux-gnu/libc.so.6 (__libc_start_main+0xe7)
CALLSTACK_TEST_CPP: #17  pc 0x55563954ac6a ./callstack_test (_start+0x2a)
Segmentation fault (core dumped)

可知问题出在函数调用 libdebugfunccrash 里面;

通过查看 libdebugfunccrash 的代码发现如下问题:

int libdebugfunccrash(int num) {
    (void)num;
    char *buff = NULL;
    buff[1] = buff[1];// will crash here
}

应用相关参考代码

/*****************************************
 * Copyright (C) 2021 * Ltd. All rights reserved.
 * File name   : libdebug.c
 *******************************************/

#include <stdio.h>
#include <stdlib.h>

#include "libdebug.h"

int libdebugfunccrash(int num) {
    (void)num;
    char *buff = NULL;
    buff[1] = buff[1];// will crash here
}
int libdebugfunc5(int num) { libdebugfunccrash(num); }
int libdebugfunc4(int num) { libdebugfunc5(num); }
int libdebugfunc3(int num) { libdebugfunc4(num); }
int libdebugfunc2(int num) { libdebugfunc3(num); }
int libdebugfunc1(int num) { libdebugfunc2(num); }

int libdebugfunc(int num) { libdebugfunc1(num); }

注册信号处理函数参考代码

/*****************************************
 * Copyright (C) 2021 * Ltd. All rights reserved.
 *
 * File name   : callstack_test.cpp
 * Created date: 2021-07-15 17:14:30
 * Description : 
 *
 *******************************************/

#include <iostream>
#include <string>
#include <vector>
#include <map>

#include <unistd.h>
#include <signal.h>

#include "libcallstack.h"
#include "libdebug.h"

void func6(int num1, int num2) {
    libdebugfunc(num1 + num2);
}

void func5(void) { func6(0, 0); }
void func4(void) { func5(); }
void func3(void) { func4(); }
void func2(void) { func3(); }
void func1(void) { func2(); }

void signal_SEGV_handler(int signo) {
    std::cout << "signal_SEGV_handler received signal: " << signo << std::endl;
#if 0
    char buf[2048+1] = { 0 };
    size_t len = 0;
    len = callstack_strings("CALLSTACK_TEST_CPP: ", buf, sizeof(buf)-1);
    if (len) {
        std::cout << buf << std::flush;
    }
#else
    callstack_dump("CALLSTACK_TEST_CPP: ");
#endif

    /* reset signal handle to default */
    signal(signo, SIG_DFL);
    /* will receive SIGSEGV again and exit app */
}

int main() {
    /* register handler of signal SIGSEGV */
    signal(SIGSEGV, signal_SEGV_handler);
    func1();
	return 0;
}
halazi100
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++中栈stack的几个常用函数
weixin_45962741的博客
02-03 9175
栈是一种只能后入先出的容器，因此只有通过top来访问栈顶元素 1、top() 代码示例： #include <iostream> #include <string> #include<algorithm> #include<bits/stdc++.h> #include<stack> #include<set> #include <vector> #include <map> #include<queue&
C/C++函数调用栈帧及其内存布局
itas109的专栏
06-24 927
每一次函数的调用,都会在调用栈(call stack)上维护一个独立的栈帧(stack frame)。局部变量初始化为x=0,y=2,z=0。局部变量初始化z=0。
c++ 基础知识(五) 函数调用栈
qq_34062754的博客
12-24 1542
1、首先我们来弄清楚栈是什么？ 栈：简单来说，栈就是一个先进后出的数据结构，这个和函数的调用过程一样，调用时，调用函数在前，被调用函数在后，返回时，被调用函数先返回，调用函数在后。 正好符合先进后出的结构。我们先来看看栈的push,和pop操作。比如往栈中压入一个元素，如下图：(左边为压入之前的图，压入之后则为右边的部分) 那如果弹出来呢 这样我们可以清楚看到栈的Push和pop操作。 2、栈帧是什么呢？ 其实栈帧本质上也是一种栈，它专门保存函数掉用的各种信息比如变量，返回地址，参数..
C++栈的基本操作及原理和STL函数
莫浅子的博客
08-17 1139
C++栈的基本操作及原理和STL函数，栈是限定仅在尾部进行插入和删除操作的线性表
调试技巧之调用堆栈 - Call stack
热门推荐
zhg598242449的专栏
05-22 2万+
简单介绍 　　调试是程序开发者必备技巧。如果不会调试，自己写的程序一旦出问题，往往无从下手。本人总结10年使用VC经验，对调试技巧做一个粗浅的介绍。希望对大家有所帮助。 　　 　　今天简单的介绍介绍调用堆栈。调用堆栈在我的专栏的文章VC调试入门提了一下，但是没有详细介绍。 　　 　　首先介绍一下什么叫调用堆栈：假设我们有几个函数，分别是function1,function2,functi
易语言调用C++ DLL隐藏函数方法-易语言
06-11
和C++一起结合起来，C++写了DLL又想隐藏函数 不知道易语言怎么调用，捣鼓下网上好像没找到合适的方法，这里记录下怕以后忘记了 先用C++写个测试DLL DEF声明加上 NONAME 意思大概就是隐藏函数名称的意思 写出DLL时候...
俄罗斯轮盘 c++进阶教学用.exe
最新发布
03-16
基本模拟俄罗斯轮盘原游戏规则，学习者可以利用此学习c++随机函数rand的使用、函数的调用、分支与循环结构。学习者可以尝试根据程序运行过程对该程序进行还原，以此锻炼自己的算法抽象能力和编程能力，同时加深对c++...
Java进阶:JNI使用技巧点滴
01-20
本文中的示例使用 Sun Microsystems 公司创建的 Java Development Kit (JDK) 版本 1.4.1。用 C 语言编写的本地代码是用 Microsoft Visual C++ 编译器编译生成。 　简介 　近日，由于项目需要，要在WEB页面实现图像...
C/C++ 入门及进阶 【第4讲 简单的计算器】
11-08
C/C++ 入门及进阶 【第4讲 简单的计算器】 本视频一步一步的讲解制作一个简单的计算器程序。 在视频中，对全局变量，局部变量，函数及调用，if 语句的执行逻辑，及程序调试的方法和注意等进行了详细的讲解。
C++进阶课程讲义1
08-08
}6.1.5函数模板遇上函数重载函数模板和普通函数区别结论： /*函数模板不允许自动类型转化普通函数能够进行自动类型转换*/函数模板和普通函数在一起，调用规则：
栈的基础函数介绍及用法
2301_76208098的博客
09-01 1192
以下是一个使用 库的例子，它展示了如何创建一个栈，向栈中推入元素，弹出栈顶元素，以及判断栈是否为空和是否满足容量要求等等
C++ 函数调用过程中栈区的变化——（栈帧、esp、ebp）
JMW1407的博客
10-11 6670
C++ 函数调用过程中栈区的变化C++ 函数调用过程中栈区的变化参考 C++ 函数调用过程中栈区的变化 参考 1、https://blog.csdn.net/m0_38087936/article/details/82938006 2、https://blog.csdn.net/fang92/article/details/46494665?utm_source=blogxgwz3 ...
【C++STL基础入门】stack栈的基础使用
m0_62599305的博客
09-26 1357
C++ STL（Standard Template Library）是C++标准库中的一个强大的工具集，提供了各种常用的数据结构和算法。其中之一就是Stack（栈），是一种后进先出（LIFO）的数据结构。使用栈可以很方便地管理数据的顺序，它具有简单、高效和易于使用的特点。本文将介绍Stack栈的基础使用方法，帮助初学者快速掌握它的概念和用法。本文简要介绍了C++ STL中Stack栈的基础使用方法。
C++中记录并解析函数调用栈callstack
halazi100
07-13 2389
glibc中提供了backtrace()和backtrace_symbols()两个函数来输出和解析程序的call stack, 输出程序运行时调用栈信息 可以通过命令man backtrace查看具体帮忙信息。 #include <execinfo.h> int backtrace(void **buffer, int size); char **backtrace_symbols(void *const *buffer, int size); 使用backtrace()函数获取调用栈
c++函数执行过程（函数栈）
Yoma0的博客
03-25 1590
本节我们重点讨论栈指针esp和帧指针ebp，围绕这两个重要的寄存器，推导出函数栈帧结构。 一：压栈和出栈的操作本质         上一节我们了解到push和pop是汇编中压栈和出栈的指令。栈这个东东，当某个程序运行时，会划分一个块固定大小的区域（存储器映射），而栈就属于这个区域的一部分。要了...
【C++】栈(stack)的使用及push与emplace异同点
AAADiao的博客
05-24 2271
C++ 中，`std::stack` 容器是一种*先进后出*(First In Last Out, FILO)的数据结构，且只有一个出口。详细介绍了C++中stack的使用方法，并分析了push与emplace的异同点。
C++函数调用栈
码上看世界
02-26 2145
在程序运行过程中，栈用于维护函数调用的上下文，离开了栈，函数调用就无法实现。
C++学习第二节：函数调用堆栈
孤傲小二~阿沐的博客
05-14 743
程序员的自我修养的第10章：详细地看 函数的调用堆栈 函数的返回值 函数的调用约定 注：C++也有面向对象 面向过程两种编程方式 int sum(int a, int b) { int temp = 0;//定义局部变量 temp = a + b; return temp; } int main() { int a = 10, b = 20;//局部变量是指令：访问局部变量都是通过ebp指...
C++函数调用栈分布详解
dvlinker的技术专栏
10-27 6108
本文详细讲述C++函数调用时的栈分布情况。
c++之递归进阶练习题
12-28
C语言中的递归是指一个函数直接或间接地调用自身的情况。递归函数包含两个部分：基线条件和递归条件。基线条件是指函数不再调用自身的条件，递归条件是指函数继续调用自身的条件。 在进行递归进阶练习时，可以尝试一些复杂的递归问题，例如斐波那契数列、阶乘计算、汉诺塔问题等。这些问题可以帮助我们更深入地理解递归的原理和运行机制。当我们解决这些问题时，需要注意递归的边界条件和递归的层数，避免出现无限递归的情况。 另外，递归函数的效率通常比较低，因为在每一层递归中都需要保存函数的状态和局部变量。因此，在进行递归进阶练习时，也可以思考如何通过其他方法来解决同样的问题，例如迭代方法或动态规划。这样可以帮助我们更全面地理解问题，并学习如何选择最优的解决方案。 总之，递归的进阶练习可以帮助我们深入理解递归的原理，提高编程能力，同时也可以启发我们思考其他解决问题的方法和技巧。在练习过程中，要注意控制递归的层数，避免出现无限递归的情况，同时也要思考其他解决方案，选择最优的解决方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值