C语言-纯c实现泛型栈

支持栈元素为 数值型，字符型，字符串

Stack.h 由于是cpp项目，调用c语言模块需要 extern “C”

//
// Created by Administrator on 2021-2-8.
// 自定义泛型栈
//

#ifndef GLOB_TEST_STACK_H
#define GLOB_TEST_STACK_H

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    // 空间大小
    int _capacity;
    // 元素个数
    int _size;
    // 元素大小
    int _element_size;
    // 模拟栈的数组
    void *element_arr;
} Stack;


typedef struct {
    int *tmp;
} empty_struct;

// 新建栈
void stack_new(Stack *s, int element_size);

// 销毁栈
void stack_delete(Stack *s);

// 入栈
void stack_push(Stack *s, void *addr);

// 出栈
void stack_pop(Stack *s, void *addr);

// 栈顶元素
void stack_back(Stack *s, void *addr);

// 栈底元素
void stack_front(Stack *s, void *addr);

// 扩展空间
void capacity_grow(Stack *s);

#ifdef __cplusplus
}
#endif

#endif //GLOB_TEST_STACK_H

Stack.c

//
// Created by Administrator on 2021-2-9.
//

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "Stack.h"

// 新建栈
void stack_new(Stack* s, int element_size){
    // 为栈分配空间
    // 栈初始元素个数为4
    s->element_arr = (char*)malloc(element_size*4);
    assert(s->element_arr != NULL);
    // 断言内存分配成功
    s->_element_size = element_size;
    s->_capacity = 4;
    s->_size = 0;
}

// 销毁栈
void stack_delete(Stack* s){
    // 断言内存可free
    assert(s->element_arr != NULL);
    free(s->element_arr);
    s->_size=0;
    s->_capacity=0;
}

// 入栈
void stack_push(Stack* s, void* addr){
    // 判断内存是否需要扩大
    if(s->_size == s->_capacity)
        capacity_grow(s);
    // 计算写入的地址
    char* target = (char *)s->element_arr + s->_size * s->_element_size;
    // 将 addr 的内容写入数组
    memcpy(target, addr, s->_element_size);
    //
    ++s->_size;
}

// 出栈
void stack_pop(Stack* s, void* addr){
    // 计算弹出的地址
    char* target = (char *)s->element_arr + s->_size * s->_element_size;
    // 将内容写入 addr
    memcpy(addr, target, s->_element_size);
}

// 栈顶元素
void stack_back(Stack* s, void* addr){
    //
    assert(s->element_arr != NULL);
    assert(s->_size != 0);
    // 计算最后一个元素的位置
    void* target = (char*)s->element_arr + (s->_size-1) * s->_element_size;
    // 调用memcpy
    memcpy(addr, target, s->_element_size);
}

// 栈底元素
void stack_front(Stack* s, void* addr){
    assert(s->element_arr != NULL);
    // 调用memcpy
    memcpy(addr, s->element_arr, s->_element_size);
}
// 扩展空间
void capacity_grow(Stack* s){
    printf("扩展空间\n");
    // 调用realloc
    s->element_arr = realloc(s->element_arr, s->_capacity*s->_element_size*2);
    assert(s->element_arr != NULL);
    s->_capacity *= 2;
}

• 数值型，字符型 调用方式

#include "../templates/Stack.h"
#include <iostream>

using namespace std;

int main(int argc, char* argv[]){

    Stack s_int;

    stack_new(&s_int, sizeof(int));
    int arr_int[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int tmp;

    for(int i=0;i<10;++i){
        stack_push(&s_int, (int*)arr_int+i);
        // 输出栈顶元素
        stack_back(&s_int, &tmp);
        printf("%d\n", tmp);
        // 输出栈底元素
        stack_front(&s_int, &tmp);
        printf("%d\n", tmp);
    }
	// 销毁栈
    stack_delete(&s_int);
    return 0;
}

• 字符串型调用方式

#include "../algorithm/a.h"
#include "../templates/Stack.h"
#include <iostream>

using namespace std;

int main(int argc, char* argv[]){

    Stack s_string;
    stack_new(&s_string, sizeof(char*));
    char* arr_string[] = {"Adam\0", "Maria\0", "Joe\0"};

    char* tmp;

    for(int i=0;i<3;++i) {
        stack_push(&s_string, arr_string + i);
        // 输出栈顶元素
        stack_back(&s_string, &tmp);
        printf("%s\n", tmp);
        // 输出栈底元素
        stack_front(&s_string, &tmp);
        printf("%s\n", tmp);
    }
    stack_delete(&s_string);
    return 0;
}