【C语言】 “函数指针”和“指针函数” 用法和详解（太细了！！！）菜鸟级教程

---

一、静态栈

1.1 静态栈的概念

静态栈是一种固定大小的栈数据结构，其大小在创建时确定，不能动态改变。静态栈使用一个数组来存储数据元素，通常分配的空间是固定的，因此在某些情况下，可能会导致栈溢出。静态栈的大小在编译时就已知，这使得它更适合一些特定的应用场景。

1.2 静态栈的特点

• 固定大小：静态栈的大小在创建时确定，无法在运行时改变。
• 使用数组：数据元素存储在数组中，栈顶指针（top）指向栈顶元素。
• 风险：可能会发生栈溢出，当栈已满时继续入栈会导致数据丢失。

1.3静态栈的示例代码

代码如下（示例）：

#include <stdio.h>
#define MAX_SIZE 10

// 静态栈结构
typedef struct
{
    int data[MAX_SIZE]; // 存储栈元素的数组
    int top;            // 栈顶指针，指向最后一个元素的位置
} StaticStack;

// 初始化静态栈
void initialize(StaticStack *stack)
{
    stack->top = -1; // 初始化栈顶指针为-1，表示栈为空
}

// 入栈操作
void push(StaticStack *stack, int value)
{
    if (stack->top < MAX_SIZE - 1)
    {                                      // 检查栈是否已满
        stack->data[++stack->top] = value; // 栈顶指针加一，然后将值存储在新栈顶位置
        printf("入栈：%d\n", value);       // 输出入栈的值
    }
    else
    {
        printf("栈已满，无法入栈\n");
    }
}

// 出栈操作
int pop(StaticStack *stack)
{
    if (stack->top >= 0)
    {                                                 // 检查栈是否为空
        int popped_value = stack->data[stack->top--]; // 弹出栈顶元素，同时栈顶指针减一
        printf("出栈：%d\n", popped_value);           // 输出出栈的值
        return popped_value;
    }
    else
    {
        printf("栈已空，无法出栈\n");
        return -1; // 返回-1表示栈为空
    }
}

// 输出栈中的元素
void display(StaticStack *stack)
{
    if (stack->top == -1)
    {
        printf("静态栈为空\n");
    }
    else
    {
        printf("静态栈中的元素: ");
        for (int i = 0; i <= stack->top; i++)
        {
            printf("%d ", stack->data[i]);
        }
        printf("\n");
    }
}

int main()
{
    StaticStack stack;
    initialize(&stack); // 初始化静态栈

    push(&stack, 1); // 入栈操作
    push(&stack, 2);
    push(&stack, 3);

    display(&stack); // 输出栈中的元素

    int popped_item = pop(&stack); // 出栈操作
    printf("出栈: %d\n", popped_item);

    display(&stack); // 再次输出栈中的元素

    return 0;
}

输出结果：入栈：1
         入栈：2
         入栈：3
         静态栈中的元素: 1 2 3 
         出栈：3
         出栈: 3
         静态栈中的元素: 1 2 

二、动态栈（链式栈）

2.1 动态栈的概念

动态栈是一种栈数据结构，其大小在运行时动态分配和释放内存，可以根据需要自动扩展或缩小，动态栈使用指针和动态内存分配。

2.2 动态栈的特点

• 动态大小：动态栈的大小可以根据需要动态增加或减小。
• 使用指针：数据元素存储在动态分配的内存中，栈顶指针（top）指向栈顶元素。
• 动态分配：内存分配由程序员控制，可以避免栈溢出的问题。

2.3 动态栈的示例代码

代码如下（示例）：

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

// 动态栈结构
typedef struct
{
    int *data;    // 存储栈元素的数组
    int top;      // 栈顶指针，指向最后一个元素的位置
    int capacity; // 栈的容量，即数组大小
} DynamicStack;

// 初始化动态栈
void initialize(DynamicStack *stack, int capacity)
{
    stack->data = (int *)malloc(sizeof(int) * capacity); // 动态分配内存
    stack->top = -1;                                     // 初始化栈顶指针为-1，表示栈为空
    stack->capacity = capacity;                          // 设置栈的容量
}

// 入栈操作
void push(DynamicStack *stack, int value)
{
    if (stack->top < stack->capacity - 1)
    {
        stack->data[++stack->top] = value; // 栈顶指针加一，然后将值存储在新栈顶位置
        printf("入栈：%d\n", value);       // 输出入栈的值
    }
    else
    {
        printf("栈已满，无法入栈\n");
    }
}

// 出栈操作
int pop(DynamicStack *stack)
{
    if (stack->top >= 0)
    {
        int popped_value = stack->data[stack->top--]; // 弹出栈顶元素，同时栈顶指针减一
        printf("出栈：%d\n", popped_value);           // 输出出栈的值
        return popped_value;
    }
    else
    {
        printf("栈已空，无法出栈\n");
        return -1; // 返回-1表示栈为空
    }
}

// 输出栈中的元素
void display(DynamicStack *stack)
{
    if (stack->top == -1)
    {
        printf("动态栈为空\n");
    }
    else
    {
        printf("动态栈中的元素: ");
        for (int i = 0; i <= stack->top; i++)
        {
            printf("%d ", stack->data[i]);
        }
        printf("\n");
    }
}

int main()
{
    int capacity = 5;
    DynamicStack stack;
    initialize(&stack, capacity); // 初始化动态栈

    push(&stack, 1); // 入栈操作
    push(&stack, 2);
    push(&stack, 3);

    display(&stack); // 输出栈中的元素

    int popped_item = pop(&stack); // 出栈操作
    display(&stack);

    free(stack.data); // 释放动态分配的内存

    return 0;
}

输出结果：入栈：1
         入栈：2
         入栈：3
         动态栈中的元素: 1 2 3 
         出栈：3
         动态栈中的元素: 1 2 

---

粉丝福利、需求解答