数据结构--（栈）总结

已于 2024-01-25 20:23:15 修改
阅读量787 收藏 20
点赞数 19
文章标签： 数据结构
于 2024-01-25 20:22:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50502677/article/details/135852641
版权

目录

1.顺序栈

（1）数据结构

（2）函数列表

1.初始化栈

2.判空

3.出栈

4.入栈

5.返回栈中元素个数

6.返回栈顶元素

7.清空栈

8.销毁栈

9.打印栈

（3）完整代码

（4）运行结果

2.链式栈

（1）数据结构

（2）函数列表

1.初始化栈

2.判空

3.入栈

4.出栈

5.返回栈中元素个数

6.返回栈顶元素

7.清空栈

8.销毁栈

9.打印栈

（3）完整代码

（4）运行结果

1.顺序栈

说明：本篇代码中，顺序栈栈顶指针初始值为 -1，代码中，数组采用的是 int 类型的指针，指向一块通过malloc 开辟的内存空间。也可以通过 Elemtype data[MAXSIZE] 指定。

（1）数据结构
#define MAXSIZE 100
typedef int Elemtype;
typedef struct SqStack
{
	//Elemtype data[MAXSIZE];
	Elemtype* data;	//指向一块内存
	int top;	//栈顶指针
}SqStack;
（2）函数列表
        1.初始化栈
//初始化栈
SqStack* Init_Stack()
{
	/*1.为结构体分配内存*/
	SqStack* Sq = (SqStack*)malloc(sizeof(SqStack));

	/*2.初始化数据指针*/
	Sq->data = (Elemtype*)malloc(sizeof(Elemtype) * MAXSIZE);

	/*3.初始化栈顶指针*/
	Sq->top = -1;

	return Sq;
}
        2.判空

注：判空时需要先判断头节点是否存在，即：判断头节点是否为空，再判断是否有元素。顺序不能反转。因为当头节点未定义时，使用 Sq->top 会造成空指针的引用，引发段错误。

//判断一个栈是否为空
bool Stack_Is_Empty(SqStack* Sq)
{
	/*1.判断头节点是否为空*/
	if (Sq == NULL)
	{
		printf("栈未定义！\n");
		return true;
	}

	/*2.判断是否有元素*/
	if (Sq->top == -1)
	{
		return true;
	}
	return false;
}
        3.出栈
//出栈
bool Pop(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	/*2.出栈*/
	*d = Sq->data[Sq->top--];  // 修正这里的顺序
	return true;
}
        4.入栈

注：元素入栈前，需要先判空，再判断栈是否已经满了，不能颠倒顺序，栈空时可能造成使用空指针的情况。

//入栈
bool Push(SqStack* Sq, Elemtype d)
{
	/*1.判空*/
	if (Sq == NULL)
	{
		printf("栈为空\n");
		return false;
	}

	/*2.判满*/
	if (Sq->top == MAXSIZE - 1)
	{
		printf("栈满,无法入栈！\n");
		return false;
	}

	/*3.入栈*/
	Sq->top += 1;
	Sq->data[Sq->top] = d;  // 修正这里的顺序

	return true;
}
        5.返回栈中元素个数

注：数组下标从 0 开始，栈底默认为 -1 所以元素的个数需要在 top 的基础上 +1

//返回栈的元素个数
int Get_Stack_Length(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return 0;
	}
	return Sq->top + 1;
}
        6.返回栈顶元素
//返回栈顶元素
bool Get_Top(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	*d =  Sq->data[Sq->top];
	return true;
}
        7.清空栈

注：直接重置 top 为 -1 即可，top 作为栈顶指针，元素读取超过 top 都是 "越界" 的情况，不考虑。新的数据会覆盖老的数据，不会造成影响。

//清空一个栈
void Clear_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return;
	}

	/*2.重置 data 数组*/
	Sq->top = -1;
}
        8.销毁栈

注：data 数组也是通过 malloc 在堆区创建的，需要手动释放，并且先与 Sq 头指针释放，否则先释放了 Sq 头指针，再去释放 data 所指向的内存可能会造成未知结果。因为 Sq 已经被释放，Sq 不一定还存有 data 的地址，或 Sq 已经被置空，造成空指针引用，引发段错误。

//销毁栈
SqStack* Destory_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Sq == NULL)
		return NULL;

	/*2.释放结点*/
	free(Sq->data);
	Sq->data = NULL;
	free(Sq);
	Sq = NULL;
	return Sq;
}
        9.打印栈

注：栈是先进后出的线性结构，这里通过 for 循环遍历，只是为了验证代码是否准确。

//打印栈
void Print_SqStack(SqStack* Sq)
{
	printf("\n打印栈：\n");
	printf("------------------------\n");
	if (Stack_Is_Empty(Sq))
	{
		printf("栈空！");
	}
	else
	{
		for (int i = 0; i <= Sq->top; i++)
		{
			printf("%d ", Sq->data[i]);
		}
	}
	printf("\n------------------------\n");
}
（3）完整代码
#include<stdio.h>
#include<stdbool.h>

#define MAXSIZE 100
typedef int Elemtype;
typedef struct SqStack
{
	//Elemtype data[MAXSIZE];
	Elemtype* data;	//指向一块内存
	int top;	//栈顶指针
}SqStack;

//初始化栈
SqStack* Init_Stack()
{
	/*1.为结构体分配内存*/
	SqStack* Sq = (SqStack*)malloc(sizeof(SqStack));

	/*2.初始化数据指针*/
	Sq->data = (Elemtype*)malloc(sizeof(Elemtype) * MAXSIZE);

	/*3.初始化栈顶指针*/
	Sq->top = -1;

	return Sq;
}

//判断一个栈是否为空
bool Stack_Is_Empty(SqStack* Sq)
{
	/*1.判断头节点是否为空*/
	if (Sq == NULL)
	{
		printf("栈未定义！\n");
		return true;
	}

	/*2.判断是否有元素*/
	if (Sq->top == -1)
	{
		return true;
	}
	return false;
}

//出栈
bool Pop(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	/*2.出栈*/
	*d = Sq->data[Sq->top--];  // 修正这里的顺序
	return true;
}

//入栈
bool Push(SqStack* Sq, Elemtype d)
{
	/*1.判空*/
	if (Sq == NULL)
	{
		printf("栈为空\n");
		return false;
	}

	/*2.判满*/
	if (Sq->top == MAXSIZE - 1)
	{
		printf("栈满,无法入栈！\n");
		return false;
	}

	/*3.入栈*/
	Sq->top += 1;
	Sq->data[Sq->top] = d;  // 修正这里的顺序

	return true;
}

//返回栈的元素个数
int Get_Stack_Length(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return 0;
	}
	return Sq->top + 1;
}

//返回栈顶元素
bool Get_Top(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	*d =  Sq->data[Sq->top];
	return true;
}

//清空一个栈
void Clear_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return;
	}

	/*2.重置 data 数组*/
	Sq->top = -1;
}

//销毁栈
SqStack* Destory_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Sq == NULL)
		return NULL;

	/*2.释放结点*/
	free(Sq->data);
	Sq->data = NULL;
	free(Sq);
	Sq = NULL;
	return Sq;
}


//打印栈
void Print_SqStack(SqStack* Sq)
{
	printf("\n打印栈：\n");
	printf("------------------------\n");
	if (Stack_Is_Empty(Sq))
	{
		printf("栈空！");
	}
	else
	{
		for (int i = 0; i <= Sq->top; i++)
		{
			printf("%d ", Sq->data[i]);
		}
	}
	printf("\n------------------------\n");
}

int main()
{
	//创建栈
	SqStack* Sq = Init_Stack();

	//判空
	Stack_Is_Empty(Sq);
	
	//入栈测试
	printf("1 2 3 4 5入栈\n");
	Push(Sq, 1);
	Push(Sq, 2);
	Push(Sq, 3);
	Push(Sq, 4);
	Push(Sq, 5);

	//输出元素个数
	printf("栈中有 %d 个元素\n", Get_Stack_Length(Sq));
	Print_SqStack(Sq);

	//获取栈顶元素
	Elemtype data;
	Get_Top(Sq, &data);
	printf("栈顶元素为：%d", data);

	//出栈
	printf("\n\n出栈两个元素\n");
	Pop(Sq, &data);
	printf("出栈:%d\n", data);
	Pop(Sq, &data);
	printf("出栈:%d\n", data);
	Print_SqStack(Sq);

	//获取栈顶元素
	Get_Top(Sq, &data);
	printf("栈顶元素为：%d\n", data);

	//清空栈
	printf("\n清空栈");
	Clear_Stack(Sq);
	//判空
	Stack_Is_Empty(Sq);
	Print_SqStack(Sq);

	//销毁栈
	printf("\n销毁栈");
	Sq = Destory_Stack(Sq);
	Print_SqStack(Sq);
	return 0;
}
（4）运行结果

2.链式栈

（1）数据结构

注：代码使用的是带头节点的双向链表模型作为栈。链表的头结点作为栈底

typedef int Elemtype;
typedef struct Node
{
	Elemtype data;
	struct Node* next;
	struct Node* prev;
}Node;

//头节点做栈顶
typedef struct LinkStack
{
	Node* top;	//指向栈顶
	Node* bottom;	//指向栈底
	int length;	//元素数量
}LinkStack;
（2）函数列表
        1.初始化栈
//初始化一个栈
LinkStack* Init_Stack()
{
	/*1.初始化头节点*/
	LinkStack* Link = (LinkStack*)malloc(sizeof(LinkStack));
	Link->top = NULL;
	Link->bottom = NULL;
    Link->length = 0;;
	return Link;
}
        2.判空
//判断一个栈是否为空
bool Stack_Is_Empty(LinkStack* LS)
{
	if (LS == NULL || LS->bottom == NULL)
	{
		printf("栈空\n");
		return true;
	}
	return false;
}
        3.入栈
//入栈
bool Push(LinkStack* LS,Elemtype d)
{
	/*1.判空*/
    if (LS == NULL)
    {
        printf("栈空！\n");
        return false;
    }
    
    /*2.创建结点*/
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = d;
    newNode->next = NULL;
    newNode->prev = NULL;


    /*3.插入元素*/
    if (LS->top == NULL)
    {   //链表中没有结点
        LS->top = newNode;
        LS->bottom = newNode;
    }
    else
    {   //首结点做栈顶，头插
        LS->top->prev = newNode;
        newNode->next = LS->top;
        LS->top = newNode;
    }
    LS->length++;
    return true;
}
        4.出栈
//出栈
bool Pop(LinkStack* LS, Elemtype *d)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
    {
        printf("栈空\n");
        return false;
    }

    /*2.获取结点的值*/
    *d = LS->top->data;

    /*3.出栈、释放空间*/
    Node* p = LS->top;
    LS->top = p->next;

    /*4.判断链表是否还有结点*/
    if(LS->top != NULL)
        LS->top->prev = NULL;
    else
    {
        LS->top = NULL;
        LS->bottom = NULL;
    }

    free(p);
    p = NULL;
    LS->length--;
    return true;
}
        5.返回栈中元素个数
//返回栈的元素个数
int Get_Stack_Length(LinkStack* LS)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return 0;
    }
    return LS->length;
}
        6.返回栈顶元素
//返回栈顶元素
void Get_Stack_Top(LinkStack* LS,Elemtype *d)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return;
    }
    *d = LS->top->data;
}
        7.清空栈
//清空一个栈
void Clear_Stack(LinkStack* LS)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
        return;

    /*2.逐个释放*/
    Node* p = NULL;
    while (LS->top)
    {
        p = LS->top;
        LS->top = p->next;
        free(p);
        p = NULL;
    }

    /*3.更新头节点*/
    LS->bottom = NULL;
    LS->top = NULL;
    LS->length = 0;
}
        8.销毁栈
//销毁一个栈
LinkStack* Destory_Stack(LinkStack* LS)
{
    Clear_Stack(LS);
    if (LS == NULL)
        return LS;
    free(LS);
    LS = NULL;
    return LS;
}
        9.打印栈
//打印栈
void Print_Stack(LinkStack* LS)
{
    printf("\n打印栈\n");
    printf("-------------------\n");
    if (Stack_Is_Empty(LS))
        printf("空栈！");
    else
    {
        Node* p = LS->top;
        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        /*逆向打印，验证链式栈是否正确链接*/
        printf("\n");
        p = LS->bottom;
        while (p)
        {
            printf("%d ", p->data);
            p = p->prev;
        }
    }
    printf("\n-------------------\n");
}
（3）完整代码
#include<stdio.h>
#include<stdbool.h>

typedef int Elemtype;
typedef struct Node
{
	Elemtype data;
	struct Node* next;
	struct Node* prev;
}Node;

//头节点做栈顶
typedef struct LinkStack
{
	Node* top;	//指向栈顶
	Node* bottom;	//指向栈底
	int length;	//元素数量
}LinkStack;

//初始化一个栈
LinkStack* Init_Stack()
{
	/*1.初始化头节点*/
	LinkStack* Link = (LinkStack*)malloc(sizeof(LinkStack));
	Link->top = NULL;
	Link->bottom = NULL;
    Link->length = 0;;
	return Link;
}

//判断一个栈是否为空
bool Stack_Is_Empty(LinkStack* LS)
{
	if (LS == NULL || LS->bottom == NULL)
	{
		printf("栈空\n");
		return true;
	}
	return false;
}

//入栈
bool Push(LinkStack* LS,Elemtype d)
{
	/*1.判空*/
    if (LS == NULL)
    {
        printf("栈空！\n");
        return false;
    }
    
    /*2.创建结点*/
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = d;
    newNode->next = NULL;
    newNode->prev = NULL;


    /*3.插入元素*/
    if (LS->top == NULL)
    {   //链表中没有结点
        LS->top = newNode;
        LS->bottom = newNode;
    }
    else
    {   //首结点做栈顶，头插
        LS->top->prev = newNode;
        newNode->next = LS->top;
        LS->top = newNode;
    }
    LS->length++;
    return true;
}

//出栈
bool Pop(LinkStack* LS, Elemtype *d)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
    {
        printf("栈空\n");
        return false;
    }

    /*2.获取结点的值*/
    *d = LS->top->data;

    /*3.出栈、释放空间*/
    Node* p = LS->top;
    LS->top = p->next;

    /*4.判断链表是否还有结点*/
    if(LS->top != NULL)
        LS->top->prev = NULL;
    else
    {
        LS->top = NULL;
        LS->bottom = NULL;
    }

    free(p);
    p = NULL;
    LS->length--;
    return true;
}

//返回栈的元素个数
int Get_Stack_Length(LinkStack* LS)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return 0;
    }
    return LS->length;
}

//返回栈顶元素
void Get_Stack_Top(LinkStack* LS,Elemtype *d)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return;
    }
    *d = LS->top->data;
}

//清空一个栈
void Clear_Stack(LinkStack* LS)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
        return;

    /*2.逐个释放*/
    Node* p = NULL;
    while (LS->top)
    {
        p = LS->top;
        LS->top = p->next;
        free(p);
        p = NULL;
    }

    /*3.更新头节点*/
    LS->bottom = NULL;
    LS->top = NULL;
    LS->length = 0;
}

//销毁一个栈
LinkStack* Destory_Stack(LinkStack* LS)
{
    Clear_Stack(LS);
    if (LS == NULL)
        return LS;
    free(LS);
    LS = NULL;
    return LS;
}

//打印栈
void Print_Stack(LinkStack* LS)
{
    printf("\n打印栈\n");
    printf("-------------------\n");
    if (Stack_Is_Empty(LS))
        printf("空栈！");
    else
    {
        Node* p = LS->top;
        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        /*逆向打印，验证链式栈是否正确链接*/
        printf("\n");
        p = LS->bottom;
        while (p)
        {
            printf("%d ", p->data);
            p = p->prev;
        }
    }
    printf("\n-------------------\n");
}

int main() {
    LinkStack* stack = Init_Stack();

    // 测试 Push
    printf("入栈10，20，30，40，50\n");
    for (int i = 1; i <= 5; i++) {
        Push(stack, i * 10);
    }

    // 测试 Get_Stack_Length
    printf("栈的长度：%d\n", Get_Stack_Length(stack));

    // 测试 Get_Stack_Top
    int data;
    Get_Stack_Top(stack,&data);

    // 测试 Print_Stack
    Print_Stack(stack);

    // 测试 Pop
    printf("出栈3个元素\n");
    for (int i = 0; i < 3; i++) {
        Pop(stack,&data);
    }

    // 测试 Pop 后的 Get_Stack_Length
    printf("Pop 后栈的长度：%d\n", Get_Stack_Length(stack));

    // 测试 Pop 后的 Print_Stack
    printf("Pop 后栈的内容：\n");
    Print_Stack(stack);

    // 测试 Clear_Stack
    printf("清空栈\n");
    Clear_Stack(stack);

    // 测试 Clear_Stack 后的 Get_Stack_Length
    printf("Clear_Stack 后栈的长度：%d\n", Get_Stack_Length(stack));
    Print_Stack(stack);

    // 测试 Clear_Stack 后的 Stack_Is_Empty
    if (Stack_Is_Empty(stack)) {
        printf("Clear_Stack 后栈为空。\n");
    }
    else {
        printf("Clear_Stack 后栈不为空。\n");
    }

    // 测试 Destory_Stack
    printf("销毁栈\n");
    stack = Destory_Stack(stack);
    Print_Stack(stack);

    return 0;
}
（4）运行结果

不想学习的奈何
关注
  • 19
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
栈&在主函数中初始化
weixin_45246477的博客
04-08 851
之前发过一篇在函数中初始化不成功的文章，是关于指针的 现在补上关于栈成功在主函数中初始化的代码 #include<stdio.h> #include<stdlib.h> #define maxsize 10 typedef int ElemType; typedef struct{ ElemType* base; ElemType top;//下标 }...
七、数据结构——链表中顺序栈详解（入栈、出栈、清空栈、打印栈等操作）
qq_57737603的博客
06-18 1118
顺序栈是一种基于数组实现的栈，它使用一块连续的内存空间来存储栈中的元素。栈顶指针（top）表示栈中最后一个元素的位置，初始时栈为空，栈顶指针通常初始化为-1。当向栈中压入（入栈）一个元素时，栈顶指针增加，并将元素存储在栈顶指针指向的位置；当从栈中弹出（出栈）一个元素时，栈顶指针减少，表示栈顶元素已被移除。顺序栈是一种基于数组实现的栈数据结构，具有先进后出的特点。它可以通过数组的连续内存空间来存储元素，并提供了一系列基本操作，如入栈、出栈、判空、判满、获取栈长度、获取栈顶元素和清空栈等。
数据结构-栈(C语言代码)
weixin_50246370的博客
08-12 5485
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct.
打印堆栈
小刀刺大熊
01-19 678
#include&amp;lt;execinfo.h&amp;gt; #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;unistd.h&amp;gt; VOID PrintBacktrace(VOID) { #define BTSIZE 100 int j, nptrs; void *buffer[100]; ch
二：栈的初始化操作及应用
@76135327的博客
11-18 4832
内容栈的顺序结点结构初始化空栈： InitStack(&S)销毁栈： DestroyStack(&S)清空栈： ClearStack(&S)判栈空: StackEmpty(S)求栈长： StackLength(S)读栈顶： GetTop(S, &e)进栈： Push(&S, e)出栈： Pop(&S, &e)链式栈的结点结构入栈出栈数值转换括号匹配问题迷宫问题表达式求值问题 栈的顺序结点结构 typedef struct { in
数据结构学习-队列/栈
最新发布
04-28
### 数据结构学习——队列与栈 #### 一、队列的基本概念 队列是一种特殊的线性表，只允许在表的一端进行插入操作，在另一端进行删除操作。这种操作方式使得队列遵循先进先出（FIFO, First In First Out）的原则。...
数据结构-匹配括号（栈）
11-07
数据结构-匹配括号（栈） 本节课程主要讲解了使用栈来实现括号匹配的算法。栈是一种基本的数据结构，它可以用来解决括号匹配问题。 栈的定义 栈是一种后进先出（LIFO）的数据结构，它可以用来存储和检索数据。栈的...
数据结构-栈10
01-20
数据结构中的栈是一种重要的线性存储结构，其主要特点...总结起来，栈作为一种基础数据结构，因其独特的“先进后出”特性，在计算机科学中有着广泛的应用，不仅在软件设计中扮演重要角色，也是理解许多高级算法的基础。
漫话数据结构-顺序栈.pptx
11-03
总结来说，顺序栈是一种基于数组实现的线性数据结构，它的主要特点是后进先出。通过对栈顶指针的有效管理，我们能够实现对栈的常见操作，包括置栈空、判断栈空、取栈顶元素、入栈和出栈。理解和熟练掌握这些操作对于...
数据结构-栈相关算法和功能
06-11
总结来说，栈是一种重要的数据结构，它的基本操作和特性使其在解决各种计算问题时起到关键作用。通过深入学习和实践，我们可以更好地利用栈来优化我们的代码和算法设计。同时，了解栈与其他数据结构如队列的差异，也...
初始化栈的代码_深入掌握栈的三种类型初始化
weixin_39530269的博客
11-20 2998
（公众号原文）概念问题：C语言是一种定义类型的语言，也就是说我们每次使用一中数据类型，我们需要先进行类型和变量定义，才能进行使用。例如：在定义这个int类型中，类型int并不占用空间，变量a占用系统所分配的4个字节大小的空间。因此，在结构体变量定义中，如在定义类型时，系统并未分配空间，只有定义一个类型变量，系统才会分配相应大小的空间。温馨提示：上述概念问题不能理解的同学，即将面临头脑风暴栈的基本操...
如何打印堆栈
sydyh43的博客
08-14 4535
一、打印堆栈可以方便问题定位，找到具体的函数调用流程。 二、打印堆栈的方法 2.1、用户态 #include <stdio.h> #include <stdlib.h> #include <stddef.h> #include <execinfo.h> #define DUMP_DEPTH 20 void dump(void) { int i = 0; size_t size = 0; char **strings = N
栈的基本操作（C语言入栈，出栈，打印栈内元素，打印栈顶元素）
qq_60304505的博客
02-09 5467
栈的基本操作（C语言入栈，出栈，打印栈内元素，打印栈顶元素）
Linux下 gdb 调试打印栈帧中的变量
wojiaxiaohuang2014的博客
11-02 3218
gdb 调试打印栈帧中的变量
堆栈打印
MiniCnCoder的博客
04-12 585
一般察看函数运行时堆栈的方法是使用GDB（bt命令）之类的外部调试器,但是,有些时候为了分析程序的BUG,(主要针对长时间运行程序的分析),在程序出错时打印出函数的调用堆栈是非常有用的。在glibc头文件"execinfo.h"中声明了三个函数用于获取当前线程的函数调用堆栈。先放例子：#include &lt;execinfo.h&gt; #include &lt;stdio.h&gt; #inc...
日志如何打印异常堆栈信息。
nobody
12-12 1万+
package com.doctor.slf4j; import org.junit.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * 如何打印异常堆栈信息。 * @author doctor * * @time 2014年12月11日 上午9:49:00 */ public class Lo
如何正确地打印异常堆栈信息
热门推荐
不积跬步，无以至千里
11-11 2万+
前言 最近老大让我修改项目里所有和log有关的代码，之前我也用过log4j、slf4j或者Logback等日志框架/接口，一直以为打印异常信息就是简单地一句log.info()或者log.error()而已，没想到原来一直都使用错了，以至于有些错误信息没能在log文件中打印出堆栈信息，最终难以定位bug，排查困难。 如何正确地打印异常的堆栈信息？ 一般在catch到异常的时候，不要使用e.prin...
打印调用堆栈
每天进步一点点，从今天开始
08-06 1295
java里面可以使用Throwable类来获取堆栈，示例代码如下： [java] view plaincopy package name.xu;   public class CallStack {       public static void printCallStatck() {           Throwable ex = n
c语言打印调用栈及解析
halazi100
10-22 1万+
#include <execinfo.h> int backtrace(void **buffer, int size); char **backtrace_symbols(void *const *buffer, int size); void backtrace_symbols_fd(void *const *buffer, int size, int fd); 代码示例...
数据结构-三叉链表解析
数据结构的学习是计算机科学的基础，涵盖了各种不同的结构，如数组、链表、栈、队列、树、图等。这些结构提供了处理不同类型信息的方法，例如，电话号码查询系统可以通过数组、链表或向量等数据结构来实现；图书馆的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值