【C语言开源库】C语言必备实用第三方库Melon(包括数据结构算法)_c melon

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

mln_string_slice_free

void mln_string_slice_free(mln_string_t *array);

描述：释放由mln_string_slice函数创建的mln_string_t数组。

返回值：无

mln_string_strcat

mln_string_t *mln_string_strcat(mln_string_t *s1, mln_string_t *s2);

描述：创建一个新的mln_string_t结构，其数据为s1和s2依此顺序拼接后的结果。

返回值：成功则返回mln_string_t指针，否则返回NULL。

mln_string_pool_strcat

mln_string_t *mln_string_pool_strcat(mln_alloc_t *pool, mln_string_t *s1, mln_string_t *s2);

描述：与mln_string_strcat功能一致，仅新的结构所使用内存由pool指向的内存池分配。

返回值：成功则返回mln_string_t指针，否则返回NULL。

双向链表

头文件

#include “mln_defs.h”

函数/宏

MLN_CHAIN_FUNC_DECLARE

MLN_CHAIN_FUNC_DECLARE(prefix,type,ret_attr,func_attr);

描述：本宏用于对双向链表的添加操作和删除操作函数进行声明，其中：

• prefix：为两个函数名的前缀，这是为了允许在一个源文件内为多个双向链表进行函数声明。
• type：链表节点的类型
• ret_attr：两个函数的操作域类型和返回值类型
• func_attr：对函数参数的约束（仅限于Linux中），若无则留空即可

MLN_CHAIN_FUNC_DEFINE

MLN_CHAIN_FUNC_DEFINE(prefix,type,ret_attr,prev_ptr,next_ptr);

ret_attr prefix##_chain_add(type **head, type **tail, type *node);
ret_attr prefix##_chain_del(type **head, type **tail, type *node);

描述：本宏用于定义双向链表的添加和删除操作函数，其中：

• prefix：为两个函数名的前缀，这是为了允许在一个源文件内为多个双向链表进行函数声明。
• type：链表节点的类型
• ret_attr：两个函数的操作域类型和返回值类型
• prev_ptr：链表节点中指向前一节点的指针名
• next_ptr：链表节点中指向后一节点的指针名

chain_add和chain_del分别为添加和删除节点函数，两个函数的参数为：

• head：二级指针，用于在操作函数内对头指针自动修改
• tail：二级指针，用于在操作函数内对尾指针自动修改
• node：被加入的节点指针，其前后指向的指针可能会被修改

示例

#include <stdio.h>
#include <stdlib.h>
#include “mln_defs.h”

typedef struct chain_s {
int val;
struct chain_s *prev;
struct chain_s *next;
} chain_t;

MLN_CHAIN_FUNC_DECLARE(test, chain_t, static inline void, );
MLN_CHAIN_FUNC_DEFINE(test, chain_t, static inline void, prev, next);

int main(void)
{
int i;
chain_t *head = NULL, *tail = NULL, *c;

for (i = 0; i < 10; ++i) {
c = (chain_t *)malloc(sizeof(chain_t));
if (c == NULL) {
fprintf(stderr, “malloc failed.\n”);
return -1;
}
c->val = i;
c->prev = c->next = NULL;
test_chain_add(&head, &tail, c);
}

for (c = head; c != NULL; c = c->next) {
printf(“%d\n”, c->val);
}
return 0;
}

栈

头文件

#include “mln_stack.h”

函数/宏

mln_stack_init

mln_stack_t *mln_stack_init(struct mln_stack_attr *attr);

struct mln_stack_attr {
stack_free free_handler;//栈节点数据释放函数
stack_copy copy_handler;//栈节点数据复制函数
mln_u32_t cache:1;//是否缓存栈节点结构
};

typedef void (*stack_free)(void *);
typedef void *(*stack_copy)(void *, void *);

描述：

初始化栈结构。

free_handler：是入栈数据的释放函数，由于入栈数据可能为自定义数据结构，因此若需释放，可对此进行设置否则置NULL。

copy_handler：复制栈节点数据。

cache：是否缓存全部栈节点结构内存以提升效率（非用户数据）。

stack_free的参数为用户自定义数据的数据结构指针。

stack_copy的参数分别为：被复制的栈节点数据的数据结构指针 和 mln_stack_dup函数的第二个参数（即用户自定义数据），这个回调函数仅在mln_stack_dup函数中被调用。

返回值：成功则返回栈指针，否则为NULL

mln_stack_destroy

void mln_stack_destroy(mln_stack_t *st);

描述：销毁栈结构，并释放栈节点内数据资源。

返回值：无

mln_stack_push

int mln_stack_push(mln_stack_t *st, void *data);

描述：将数据data压入栈st中。

返回值：成功返回0，否则返回-1

mln_stack_pop

void *mln_stack_pop(mln_stack_t *st);

描述：将栈st的栈顶元素数据弹出。

返回值：若栈内无元素则为NULL，否则为栈节点内的数据指针

mln_stack_empty

mln_stack_empty(s)

描述：判断栈是否为空。

返回值：空为非0，否则为0

mln_stack_top

mln_stack_top(st)

描述：获取栈顶元素数据。

返回值：若栈st为空则返回NULL，否则为栈顶节点内的数据指针

mln_stack_dup

mln_stack_t *mln_stack_dup(mln_stack_t *st, void *udata);

描述：完全复制栈st。udata为用户提供的额外数据。

返回值：若成功则返回新栈指针，否则返回NULL

mln_stack_scan_all

int mln_stack_scan_all(mln_stack_t *st, stack_scan scanner, void *data);

typedef int (*stack_scan)(void *, void *);

描述：

从栈顶向栈底遍历栈st的每一个栈内元素数据。scanner为数据访问函数，data为遍历时的额外用户数据。

stack_scan有两个参数，分别为：栈节点内数据指针 和 data参数。

返回值：

• mln_stack_scan_all：全部遍历完则返回0，否则返回-1
• stack_scan：若想中断遍历则返回小于0的值，否则返回值大于等于0

队列

头文件

#include “mln_queue.h”

函数/宏

mln_queue_init

mln_queue_t *mln_queue_init(struct mln_queue_attr *attr);

struct mln_queue_attr {
mln_uauto_t qlen; //队列长度
queue_free free_handler; //队列节点数据的释放函数
};
typedef void (*queue_free)(void *);

描述：创建队列。

本队列为固定长度队列，因此attr.qlen就是队列的长度。free_handler为释放函数，用于释放队列内每个成员中的数据。若不需要释放则置NULL即可。

释放函数的参数即为队列每个成员的数据结构指针。

返回值：成功则返回mln_queue_t类型的队列指针，失败则返回NULL

mln_queue_destroy

void mln_queue_destroy(mln_queue_t *q);

描述：销毁队列。

队列销毁时，会根据free_handler的设置而自动释放队列成员的数据。

返回值：无

mln_queue_append

int mln_queue_append(mln_queue_t *q, void *data);

描述：将数据data追加进队列q的末尾。

返回值：若队列已满则返回-1，成功返回0

mln_queue_get

void *mln_queue_get(mln_queue_t *q);

描述：获取队首成员的数据。

返回值：成功则返回数据指针，若队列为空则返回NULL

mln_queue_remove

void mln_queue_remove(mln_queue_t *q);

描述：删除队首元素，但不释放资源。

返回值：无

mln_queue_search

void *mln_queue_search(mln_queue_t *q, mln_uauto_t index);

描述：查找并返回从队列q队首开始的第index成员的数据，下标从0开始。

返回值：成功则返回数据指针，否则为NULL

mln_queue_free_index

void mln_queue_free_index(mln_queue_t *q, mln_uauto_t index);

描述：释放队列q内指定下标index的成员，并根据free_handler释放其数据。

返回值：无

mln_queue_scan_all

int mln_queue_scan_all(mln_queue_t *q, queue_scan scan_handler, void *udata);

typedef int (*queue_scan)(void *, void *);

描述：遍历每一个队列成员。

udata为辅助遍历的自定义结构指针，若不需要可置NULL。

scan_handler的两个参数分别为：成员数据，udata。

返回值：遍历完成返回0，被中断则返回-1

mln_queue_empty

mln_queue_empty(q)

描述：判断队列q是否为空队列。

返回值：空则为非0，否则为0

mln_queue_full

mln_queue_full(q)

描述：判断队列是否已满。

返回值：满则为非0，否则为0

mln_queue_length

mln_queue_length(q)

描述：获取队列q的总长度。

返回值：无符号整型长度值

mln_queue_element

mln_queue_element(q)

描述：获取队列q中当前的成员数量。

返回值：无符号整型数量值

示例

#include <stdio.h>
#include <stdlib.h>
#include “mln_core.h”
#include “mln_log.h”
#include “mln_queue.h”

int main(int argc, char *argv[])
{
int i = 10;
mln_queue_t *q;
struct mln_queue_attr qattr;
struct mln_core_attr cattr;

cattr.argc = argc;
cattr.argv = argv;
cattr.global_init = NULL;
cattr.worker_process = NULL;
if (mln_core_init(&cattr) < 0) {
fprintf(stderr, “init failed\n”);
return -1;
}

qattr.qlen = 10;
qattr.free_handler = NULL;
q = mln_queue_init(&qattr);
if (q == NULL) {
mln_log(error, “queue init failed.\n”);
return -1;
}
mln_queue_append(q, &i);
mln_log(debug, “%d\n”, *(int *)mln_queue_get(q));
mln_queue_destroy(q);

return 0;
}

内存池

Melon中，内存池分为两类：

• 堆内存
• 共享内存

其中，共享内存内存池只允许主子进程之间共享数据（兄弟进程之间也共享）。即使用时，由主进程创建共享内存内存池，然后创建子进程。

头文件

#include “mln_alloc.h”

函数

mln_alloc_init

mln_alloc_t *mln_alloc_init(void);

描述：创建堆内存内存池。

返回值：成功则返回内存池结构指针，否则返回NULL

mln_alloc_shm_init

mln_alloc_t *mln_alloc_shm_init(mln_size_t size);

描述：创建共享内存内存池。本池建立时需要给出池大小size（单位字节），一旦创建完毕后则后续无法再扩大。

返回值：成功则返回内存池结构指针，否则返回NULL

mln_alloc_destroy

void mln_alloc_destroy(mln_alloc_t *pool);

描述：销毁内存池。销毁操作会将内存池中管理的所有内存进行统一释放。

返回值：无

mln_alloc_m

void *mln_alloc_m(mln_alloc_t *pool, mln_size_t size);

描述：从内存池pool中分配一个size大小的内存。如果内存池是共享内存内存池，则会从共享内存中进行分配，否则从堆内存中进行分配。

返回值：成功则返回内存起始地址，否则返回NULL

mln_alloc_c

void *mln_alloc_c(mln_alloc_t *pool, mln_size_t size);

描述：从内存池pool中分配一个size大小的内存，且该内存会被清零。

返回值：成功则返回内存起始地址，否则返回NULL

mln_alloc_re

void *mln_alloc_re(mln_alloc_t *pool, void *ptr, mln_size_t size);

描述：从内存池pool中分配一个