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

最新推荐文章于 2024-07-31 17:24:32 发布
最新推荐文章于 2024-07-31 17:24:32 发布
阅读量921 收藏 8
点赞数 10
分类专栏： 程序员 文章标签： go 学习 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84925558/article/details/138774952
版权

img
img
img

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

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

如果你需要这些资料，可以戳这里获取

mln_string_nset
mln_string_nset(pstr, s, n)

描述：与mln_string_set功能一样，只是pstr所指向的mln_string_t仅记录了s的前n个字节。

返回值：无

举例：

void foo()
{
  char text[] = "hello world";
  mln_string_t s;
  mln\_string\_nset(&s, text, 5); //利用mln\_log的%S进行输出时，仅会输出hello
}
mln_string_ref
mln_string_ref(pstr)

描述：将pstr所指向的mln_string_t结构的ref成员累加1，用于直接引用pstr这个内存结构。在释放内存时，引用计数大于1时是不会实际释放内存的。

返回值：mln_string_t类型指针

void foo(mln_string_t s)
{
  mln_string_t \*ref = mln\_string\_ref(s); //此时ref与s的内存地址完全相同
  ...
}
mln_string_free
mln_string_free(pstr)

描述：释放ptrs所指向的mln_string_t结构内存，若ref大于1则仅递减引用计数，若data_ref为1，则不释放data成员指向的内存，否则释放data成员内存，随后释放pstr内存。释放时，会根据pool成员判断是释放回内存池，还是返还malloc库。

返回值：无

mln_string_new
mln_string_t *mln_string_new(const char *s);

描述：根据字符串常量s创建字符串结构，此时新字符串结构及其数据部分内存均由malloc库进行分配，并将s的内容拷贝进data成员中。

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

mln_string_pool_new
mln_string_t *mln_string_pool_new(mln_alloc_t *pool, const char *s);

描述：与mln_string_new功能一致，仅内存是由pool所指向的内存池中分配而来。

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

mln_string_dup
mln_string_t *mln_string_dup(mln_string_t *str);

描述：完全复制一份str，其内存均由malloc进行分配。

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

mln_string_pool_dup
mln_string_t *mln_string_pool_dup(mln_alloc_t *pool, mln_string_t *str);

描述：与mln_string_dup功能一致，仅内存是从pool所指向的内存池中分配而来。

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

mln_string_ndup
mln_string_t *mln_string_ndup(mln_string_t *str, mln_s32_t size);

描述：创建一个新字符串对象，并仅复制str中前size个字节数据。

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

mln_string_const_ndup
mln_string_t *mln_string_const_ndup(char *str, mln_s32_t size);

描述：创建一个新字符串对象，并仅复制str中前size个字节数据。

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

mln_string_ref_dup
mln_string_t *mln_string_ref_dup(mln_string_t *str);

描述：创建一个新的字符串结构，但结构中的data成员指向str中data成员所指向的地址，且新结构中data_ref会被置位。

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

mln_string_const_ref_dup
mln_string_t *mln_string_const_ref_dup(char *s);

描述：创建一个新的字符串结构，但结构中的data成员指向s，且新结构中data_ref会被置位。

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

mln_string_strseqcmp
int mln_string_strseqcmp(mln_string_t *s1, mln_string_t *s2);

描述：比较s1与s2的数据，如果短的一方刚好与长的一方的前面完全匹配，则长的一方大于短的一方。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同

举例：

int main(void)
{
  mln_string_t s1 = mln\_string("abcd");
  mln_string_t s2 = mln\_string("abcdefg");
  printf("%d", mln\_string\_strseqcmp(&s1, &s2)); //-1
  return 0;
}
mln_string_strcmp
int mln_string_strcmp(mln_string_t *s1, mln_string_t *s2);

描述：比较s1与s2中数据的大小。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_const_strcmp
int mln_string_const_strcmp(mln_string_t *s1, char *s2);

描述：比较s1所记录的数据与s2的大小。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_strncmp
int mln_string_strncmp(mln_string_t *s1, mln_string_t *s2, mln_u32_t n);

描述：比较s1与s2的前n个字节的大小。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_const_strncmp
int mln_string_const_strncmp(mln_string_t *s1, char *s2, mln_u32_t n);

描述：比较s1所记录的数据与s2的前n个字节的大小。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_strcasecmp
int mln_string_strcasecmp(mln_string_t *s1, mln_string_t *s2);

描述：比较s1与s2数据的大小，且忽略大小写。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_const_strcasecmp
int mln_string_const_strcasecmp(mln_string_t *s1, char *s2);

描述：比较s1所记录的数据与s2的大小，且忽略大小写。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_const_strncasecmp
int mln_string_const_strncasecmp(mln_string_t *s1, char *s2, mln_u32_t n);

描述：比较s1所记录的数据与s2的前n个字节的大小，且忽略大小写。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_strncasecmp
int mln_string_strncasecmp(mln_string_t *s1, mln_string_t *s2, mln_u32_t n);

描述：比较s1与s2所记录数据的前n个字节的大小，且忽略大小写。

返回值：

  • -1 - s1比s2小
  • 1 - s1比s2大
  • 0 - 二者相同
mln_string_strstr
char *mln_string_strstr(mln_string_t *text, mln_string_t *pattern);

描述：匹配text所记录的数据中与pattern中数据一样的起始地址。

返回值：若匹配成功，则返回text的data成员所指向地址中的对应地址；否则返回NULL。

mln_string_const_strstr
char *mln_string_const_strstr(mln_string_t *text, char *pattern);

描述：匹配text所记录的数据中与pattern一样的起始地址。

返回值：若匹配成功，则返回text的data成员所指向地址中的对应地址；否则返回NULL。

mln_string_new_strstr
mln_string_t *mln_string_new_strstr(mln_string_t *text, mln_string_t *pattern);

描述：与mln_string_strstr功能一致，但返回的是由mln_string_t结构包装后的字符串。

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

mln_string_new_const_strstr
mln_string_t *mln_string_new_const_strstr(mln_string_t *text, char *pattern);

描述：与mln_string_const_strstr功能一致，但返回的是由mln_string_t结构包装后的字符串。

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

mln_string_kmp
char *mln_string_kmp(mln_string_t *text, mln_string_t *pattern);

描述：与mln_string_strstr功能一致，但是是由KMP算法实现的。KMP算法适用场景是，text中有较多与pattern前缀相同的字符串的情况。例如: text中包含aaaaaaaaaabc，pattern中包含ab，此时，KMP算法性能将高于朴素算法。

返回值：若匹配成功，则返回text的data成员所指向地址中的对应地址；否则返回NULL。

mln_string_const_kmp
char *mln_string_const_kmp(mln_string_t *text, char *pattern);

描述：与mln_string_kmp功能一致，但pattern为字符指针类型。

返回值：若匹配成功，则返回text的data成员所指向地址中的对应地址；否则返回NULL。

mln_string_new_kmp
mln_string_t *mln_string_new_kmp(mln_string_t *text, mln_string_t *pattern);

描述：与mln_string_kmp功能一致，但返回的是由mln_string_t结构包装后的数据。

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

mln_string_new_const_kmp
mln_string_t *mln_string_new_const_kmp(mln_string_t *text, char *pattern);

描述：与mln_string_const_kmp功能一致，但返回的是由mln_string_t结构包装后的数据。

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

mln_string_slice
mln_string_t *mln_string_slice(mln_string_t *s, const char *sep_array/*ended by \0*/);

描述：seq_array是一个字符数组且以0结尾，该数组的每一个字符都是一个分隔标志。函数会扫描s的数据部分，当数据中遇到seq_array中的任意一个字符时都会被进行分割，连续遇到多个时仅分割一次，且分割后，分隔符不会出现在被分割后的字符串中。

返回值：成功则返回mln_string_t数组，否则返回NULL。数组的最后一个元素的len为0，且data为NULL。

举例：

int main(void)
{
  mln_string_t s = mln\_string("abc-def-=ghi");
  mln_string_t \*str, \*arr = mln\_string\_slice(&s, "-=");
  for (str = arr; str->data != NULL; ++str) {
    mln\_log(debug, "%S", str);
  }
  mln\_string\_slice\_free(arr);
  return 0;
}
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中分配一个size大小的内存，并将ptr指向的内存中的数据拷贝到新的内存中。

ptr必须为内存池分配的内存起始地址。若size为0，ptr指向的内存会被释放。

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

mln_alloc_free

void mln_alloc_free(void *ptr);

描述：释放ptr指向的内存。注意：ptr必须为分配函数返回的地址，而不可以是分配的内存中某一个位置。

返回值：无

mln_alloc_shm_rdlock

int mln_alloc_shm_rdlock(mln_alloc_t *pool);

描述：读锁定。本函数会等待直到锁资源可用，并将之锁定。

本函数及后续锁相关函数均用于共享内存内存池。

出于对读多写少的场景考虑，给共享内存配备的是读写锁，而非互斥锁。

返回值：成功返回0，否则返回非0

mln_alloc_shm_tryrdlock

int mln_alloc_shm_tryrdlock(mln_alloc_t *pool);

描述：尝试读锁定。本函数不会挂起等待锁资源可用。

返回值：成功返回0，否则返回非0

mln_alloc_shm_wrlock

int mln_alloc_shm_wrlock(mln_alloc_t *pool);

描述：写锁定。本函数会等待直到锁资源可用，并将之锁定。

返回值：成功返回0，否则返回非0

mln_alloc_shm_trywrlock

int mln_alloc_shm_trywrlock(mln_alloc_t *pool);

描述：尝试写锁定。本函数不会挂起等待锁资源可用。

返回值：成功返回0，否则返回非0

mln_alloc_shm_unlock

int mln_alloc_shm_unlock(mln_alloc_t *pool);

描述：解除锁定。

返回值：成功返回0，否则返回非0

示例

#include <stdio.h>
#include <stdlib.h>
#include "mln\_core.h"
#include "mln\_log.h"
#include "mln\_alloc.h"

int main(int argc, char \*argv[])
{
    char \*p;
    mln_alloc_t \*pool;
    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;
    }

    pool = mln\_alloc\_init();
    if (pool == NULL) {
        mln\_log(error, "pool init failed\n");
        return -1;
    }

    p = (char \*)mln\_alloc\_m(pool, 6);
    if (p == NULL) {
        mln\_log(error, "alloc failed\n");
        return -1;
    }

    memcpy(p, "hello", 5);
    p[5] = 0;
    mln\_log(debug, "%s\n", p);

    mln\_alloc\_free(p);

    return 0;
}

线程池

在Melon中支持两种多线程模式，线程池是其中一种，另一种请参见后续的多线程框架文章。

注意：在每个进程中仅允许存在一个线程池。

头文件
#include "mln_thread_pool.h"
函数
mln_thread_pool_run
int mln\_thread\_pool\_run(struct mln_thread_pool_attr \*tpattr);

struct mln_thread_pool_attr {
    void                              \*main_data;
    mln_thread_process                 child_process_handler;
    mln_thread_process                 main_process_handler;
    mln_thread_dataFree                free_handler;
    mln_u64_t                          cond_timeout; /\*ms\*/
    mln_u32_t                          max;
    mln_u32_t                          concurrency;
};
typedef int  (\*mln_thread_process)(void \*);
typedef void (\*mln_thread_dataFree)(void \*);

描述：创建并运行内存池。

线程池由主线程进行管理和做一部分处理后下发任务，子线程组则接受任务进行处理。

初始状态下，是不存在子线程的，当有任务需要下发时会自动创建子线程。当任务处理完后，子线程会延迟释放，避免频繁分配释放资源。

其中参数结构体的每个成员含义如下：

  • main_data 为主线程的用户自定义数据。
  • child_process_handler 每个子线程的处理函数，该函数有一个参数为主线程下发任务时给出的数据结构指针，返回值为0表示处理正常，非0表示处理异常，异常时会有日志输出。
  • main_process_handler 主线程的处理函数，该函数有一个参数为main_data，返回值为0表示处理正常，非0表示处理异常，异常时会有日志输出。一般情况下，主线程处理函数不应随意自行返回，一旦返回代表线程池处理结束，线程池会被销毁。
  • free_handler 为资源释放函数。其资源为主线程下发给子线程的数据结构指针所指向的内容。
  • cond_timeout为闲置子线程回收定时器，单位为毫秒。当子线程无任务处理，且等待时间超过该定时器时长后，会自行退出。
  • max线程池允许的最大子线程数量。
  • concurrency用于pthread_setconcurrency设置并行级别参考值，但部分系统并为实现该功能，因此不应该过多依赖该值。在Linux下，该值设为零表示交由本系统实现自行确定并行度。

返回值：本函数返回值与主线程处理函数的返回值保持一致

mln_thread_pool_addResource
int mln_thread_pool_addResource(void *data);

描述：将资源data放入到资源池中。本函数仅应由主线程调用，用于主线程向子线程下发任务所用。

返回值：成功则返回0，否则返回非0

mln_thread_quit
void mln_thread_quit(void);

描述：本函数用于告知线程池，关闭并销毁线程池。

返回值：无

mln_thread_ResourceInfo
void mln\_thread\_ResourceInfo(struct mln_thread_pool_info \*info);

struct mln_thread_pool_info {
    mln_u32_t                          max_num;
    mln_u32_t                          idle_num;
    mln_u32_t                          cur_num;
    mln_size_t                         res_num;
};

描述：获取当前线程池信息。信息会写入参数结构体中，结构体每个参数含义如下：

  • max_num：线程池最大子线程数量
  • idle_num：当前闲置子线程数量
  • cur_num：当前子线程数量（包含闲置和工作中的子线程）
  • res_num：当前尚未被处理的资源数量

返回值：无

示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "mln\_core.h"
#include "mln\_thread\_pool.h"
#include "mln\_log.h"

static int main\_process\_handler(void \*data);
static int child\_process\_handler(void \*data);
static void free\_handler(void \*data);

int main(int argc, char \*argv[])
{
    struct mln_core_attr cattr;
    struct mln_thread_pool_attr tpattr;

    cattr.argc = argc;
    cattr.argv = argv;
    cattr.global_init = NULL;
    cattr.worker_process = NULL;
    if (mln\_core\_init(&cattr) < 0) {
        return -1;
    }

    tpattr.dataForMain = NULL;
    tpattr.child_process_handler = child_process_handler;
    tpattr.main_process_handler = main_process_handler;
    tpattr.free_handler = free_handler;
    tpattr.condTimeout = 10;
    tpattr.max = 10;
    tpattr.concurrency = 10;
    return mln\_thread\_pool\_run(&tpattr);
}

static int child\_process\_handler(void \*data)
{
    mln\_log(none, "%s\n", (char \*)data);
    return 0;
}

static int main\_process\_handler(void \*data)
{
    int n;
    char \*text;

    while (1) {
        if ((text = (char \*)malloc(16)) == NULL) {
            return -1;
        }
        n = snprintf(text, 15, "hello world");
        text[n] = 0;
        mln\_thread\_pool\_addResource(text);
        usleep(1000);
    }
}

static void free\_handler(void \*data)
{
    free(data);
}

JSON

头文件
#include "mln_json.h"
函数/宏
mln_json_new
mln_json_t *mln_json_new(void);

描述：新建json节点，用于生成json字符串之用。

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

mln_json_parse
mln_json_t *mln_json_parse(mln_string_t *jstr);

描述：将JSON字符串jstr解析成数据结构。

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

mln_json_free
void mln_json_free(void *json);

描述：释放mln_json_t类型的json节点内存。

返回值：无

mln_json_dump
void mln_json_dump(mln_json_t *j, int n_space, char *prefix);

描述：将json节点j的详细信息输出到标准输出。n_space表示当前缩进空格数，prefix为输出内容的前缀。

返回值：无

mln_json_generate
mln_string_t *mln_json_generate(mln_json_t *j);

描述：由mln_json_t节点结构生成JSON字符串。

返回值：成功返回mln_string_t字符串指针，否则返回NULL

mln_json_search_value
mln_json_t *mln_json_search_value(mln_json_t *j, mln_string_t *key);

描述：从节点j中搜索key为key的value内容。此时，j必须为对象类型（有key: value对的字典）。

返回值：成功则返回mln_json_t类型的value，否则返回NULL

mln_json_search_element
mln_json_t *mln_json_search_element(mln_json_t *j, mln_uauto_t index);

描述：从节点j中搜索下标为index的元素内容。此时，j必须为数组类型。

返回值：成功则返回mln_json_t类型的元素节点，否则返回NULL

mln_json_get_array_length
mln_uauto_t mln_json_get_array_length(mln_json_t *j);

描述：获取数组的长度。此时j必须为数组类型。

返回值：数组长度

mln_json_update_obj
int mln_json_update_obj(mln_json_t *j, mln_json_t *key, mln_json_t *val);

描述：将key与val对添加到j JSON节点中。此时，j需为对象类型。若key已经存在，则将原本value替换为val。

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

mln_json_add_element
int mln_json_add_element(mln_json_t *j, mln_json_t *value);

描述：将value加入到数组类型的JSON结构j中。

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

mln_json_update_element
int mln_json_update_element(mln_json_t *j, mln_json_t *value, mln_uauto_t index);

描述：将value更新到数组类型JSON结构j的下标为index的位置上。

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

mln_json_reset
void mln_json_reset(mln_json_t *j);

描述：重置JSON节点j数据结构，将其内存进行释放。

返回值：无

mln_json_remove_object
mln_json_t *mln_json_remove_object(mln_json_t *j, mln_string_t *key);

描述：将key值为key的键值对从对象类型的JSON结构j中删除，并将相应value返回。

返回值：存在则返回对应value部分的JSON节点，否则返回NULL

mln_json_remove_element
mln_json_t *mln_json_remove_element(mln_json_t *j, mln_uauto_t index);

描述：将下标为index的元素从数组类型JSON节点上删除并返回。

返回值：存在则返回元素指针，否则返回NULL

is_type
M\_JSON\_IS\_OBJECT(json)
M\_JSON\_IS\_ARRAY(json)
M\_JSON\_IS\_STRING(json)
M\_JSON\_IS\_NUMBER(json)
M\_JSON\_IS\_TRUE(json)
M\_JSON\_IS\_FALSE(json)
M\_JSON\_IS\_NULL(json)
M\_JSON\_IS\_NONE(json)

描述：判断mln_json_t结构的json类型，依次分别为：对象、数组、字符串、数字、布尔真、布尔假、NULL、无类型。

返回值：满足条件返回非0，否则返回0

set_type
M\_JSON\_SET\_TYPE\_NONE(json)
M\_JSON\_SET\_TYPE\_OBJECT(json)
M\_JSON\_SET\_TYPE\_ARRAY(json)
M\_JSON\_SET\_TYPE\_STRING(json)
M\_JSON\_SET\_TYPE\_NUMBER(json)
M\_JSON\_SET\_TYPE\_TRUE(json)
M\_JSON\_SET\_TYPE\_FALSE(json)
M\_JSON\_SET\_TYPE\_NULL(json)

描述：给mln_json_t类型的json节点设置类型，依次分别为：无类型、对象、数组、字符串、数字、布尔真、布尔假、NULL。

返回值：无

get_data
M\_JSON\_GET\_DATA\_OBJECT(json)
M\_JSON\_GET\_DATA\_ARRAY(json)
M\_JSON\_GET\_DATA\_STRING(json)
M\_JSON\_GET\_DATA\_NUMBER(json)
M\_JSON\_GET\_DATA\_TRUE(json)
M\_JSON\_GET\_DATA\_FALSE(json)
M\_JSON\_GET\_DATA\_NULL(json)

描述：获取mln_json_t类型的json节点中对应类型的数据部分。类型依次为：对象、数组、字符串、数字、布尔真、布尔假、NULL。

返回值：

  • 对象类型为mln_hash_t类型指针
  • 数组类型为mln_rbtree_t类型指针
  • 字符串类型为mln_string_t类型指针
  • 数字类型为double类型值
  • 布尔真为mln_u8_t类型值
  • 布尔假为mln_u8_t类型值
  • NULL类型为mln_u8ptr_t类型的NULL值
set_data
M_JSON_SET_DATA_STRING(json,str)
M_JSON_SET_DATA_NUMBER(json,num)
M_JSON_SET_DATA_TRUE(json)
M_JSON_SET_DATA_FALSE(json)
M_JSON_SET_DATA_NULL(json)

描述：给不同类型的JSON节点json设置数据值。对象和数组类型分别使用哈希表和红黑树函数进行操作，其余类型用上述宏进行设置。

注意：这里设置的字符串必须是从内存池或堆中分配的内存，栈中内存会出现段错误，因为赋值时不会在宏内自动复制一份而是直接使用。

返回值：无

M_JSON_SET_INDEX
M_JSON_SET_INDEX(json,i)

描述：设置mln_json_t类型节点json的下标为index。该宏用于生成JSON字符串中数组的部分。

返回值：无

示例
#include <stdio.h>
#include <stdlib.h>
#include "mln\_core.h"
#include "mln\_log.h"
#include "mln\_string.h"
#include "mln\_json.h"

int main(int argc, char \*argv[])
{
    mln_json_t \*j = NULL, \*key = NULL, \*val = NULL;
    mln_string_t s1 = mln\_string("name");
    mln_string_t s2 = mln\_string("Tom");
    mln_string_t \*res;
    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;
    }

    key = mln\_json\_new();
    if (key == NULL) {
        mln\_log(error, "init key failed\n");
        goto err;
    }
    M\_JSON\_SET\_TYPE\_STRING(key);
    M\_JSON\_SET\_DATA\_STRING(key, mln\_string\_dup(&s1));//注意，一定是要自行分配内存，不可直接使用栈中内存

    val = mln\_json\_new();
    if (val == NULL) {
        mln\_log(error, "init val failed\n");
        goto err;
    }
    M\_JSON\_SET\_TYPE\_STRING(val);
    M\_JSON\_SET\_DATA\_STRING(val, mln\_string\_dup(&s2));//注意，一定是要自行分配内存，不可直接使用栈中内存

    j = mln\_json\_new();
    if (j == NULL) {
        mln\_log(error, "init object failed\n");
        goto err;
    }
    if (mln\_json\_update\_obj(j, key, val) < 0) {
        mln\_log(error, "update object failed\n");
        goto err;
    }
    key = val = NULL;

    res = mln\_json\_generate(j);
    mln\_json\_free(j);
    if (res == NULL) {
        mln\_log(error, "generate failed\n");
        goto err;
    }
    mln\_log(debug, "%S\n", res);

    j = mln\_json\_parse(res);
    mln\_string\_free(res);
    mln\_json\_dump(j, 0, NULL);

    mln\_json\_free(j);

    return 0;

err:
    if (j != NULL) mln\_json\_free(j);
    if (key != NULL) mln\_json\_free(key);
    if (val != NULL) mln\_json\_free(val);
    return -1;
}

HTTP

头文件
#include "mln_http.h"
函数/宏
mln_http_init
mln_http_t *mln_http_init(mln_tcp_conn_t *connection, void *data, mln_http_handler body_handler);

typedef int (*mln_http_handler)(mln_http_t *, mln_chain_t **, mln_chain_t **);

描述：创建并初始化mln_http_t结构。connection是TCP结构，内含TCP套接字。data为体处理函数的用户自定义数据部分，用于辅助请求或响应体的处理。body_handler是体处理函数，该函数会在每次调用mln_http_parse或mln_http_generate函数时被调用。体处理函数有三个参数，分别为：http结构，用于解析或生成HTTP报文的双向链表的头和尾节点。

返回值：成功则返回mln_http_t结构指针，否则返回NULL

mln_http_destroy
void mln_http_destroy(mln_http_t *http);

描述：销毁http结构并释放资源。

返回值：无

mln_http_reset
void mln_http_reset(mln_http_t *http);

描述：重置http结构，但不会将结构释放，可用于下一次处理。

返回值：无

mln_http_parse
int mln_http_parse(mln_http_t *http, mln_chain_t **in);

描述：用于解析HTTP报文，并将解析的结果写入http中。

返回值：

  • M_HTTP_RET_DONE 解析完成
  • M_HTTP_RET_OK 解析未完成但未出错，继续传入新的数据使解析完成
  • M_HTTP_RET_ERROR 解析失败
mln_http_generate
int mln_http_generate(mln_http_t *http, mln_chain_t **out_head, mln_chain_t **out_tail);

描述：将http中HTTP相关信息生成HTTP报文。报文可能不会一次性生成完全，因此可以多次调用。已生成的报文将会存放在out_head和out_tail指定的双向链表中。

返回值：

  • M_HTTP_RET_DONE 生成完成
  • M_HTTP_RET_OK 生成未完成但未出错
  • M_HTTP_RET_ERROR 生成失败
mln_http_set_field
int mln_http_set_field(mln_http_t *http, mln_string_t *key, mln_string_t *val);

描述：设置HTTP头字段。若头字段key存在，则会将val替换原有值。

返回值：

  • M_HTTP_RET_OK 处理成功
  • M_HTTP_RET_ERROR处理失败
mln_http_get_field
mln_string_t *mln_http_get_field(mln_http_t *http, mln_string_t *key);

描述：获取HTTP头字段中键为key的值。

返回值：成功则返回值字符串结构指针，否则返回NULL

mln_http_field_iterator
mln_string_t *mln_http_field_iterator(mln_http_t *http, mln_string_t *key);

描述：每次返回一个键为key的头字段值（即假设存在多个相同键名的头字段）。

返回值：成功则返回值字符串结构指针，否则返回NULL

mln_http_drop_field
void mln_http_drop_field(mln_http_t *http, mln_string_t *key);

描述：移除头字段key及其值。

返回值：无

mln_http_dump
void mln_http_dump(mln_http_t *http);

描述：将HTTP信息输出到标准输出，用于调试之用。

返回值：无

mln_http_get_connection
mln_http_get_connection(h)

描述：获取类型为mln_http_t的h中TCP链接结构。

返回值：mln_tcp_conn_t类型指针

mln_http_set_connection
mln_http_set_connection(h,c)

描述：将mln_http_t类型的h中TCP链接结构设置为mln_tcp_conn_t类型的c。

返回值：无

mln_http_get_pool
mln_http_get_pool(h)

描述：获取类型为mln_http_t的h中内存池结构。

返回值：mln_alloc_t类型指针

mln_http_set_pool
mln_http_set_pool(h,p)

描述：将mln_http_t类型的h中内存池设置为mln_alloc_t类型的p。

返回值：无

mln_http_get_data
mln_http_get_data(h)

描述：获取类型为mln_http_t的h中辅助体处理函数的用户自定义数据。

返回值：用户自定义数据指针

mln_http_set_data
mln_http_set_data(h,d)

描述：将mln_http_t类型的h中辅助体处理函数的用户自定义数据设置为d。

返回值：无

mln_http_get_uri
mln_http_get_uri(h)

描述：获取类型为mln_http_t的h中URI字符串。

返回值：mln_string_t类型指针

mln_http_set_uri
mln_http_set_uri(h,u)

描述：将mln_http_t类型的h中URI设置为mln_string_t类型指针的u。

返回值：无

mln_http_get_args
mln_http_get_args(h)

描述：获取类型为mln_http_t的h中参数字符串。

返回值：mln_string_t类型指针

mln_http_set_args
mln_http_set_args(h,a)

描述：将mln_http_t类型的h中参数设置为mln_string_t类型指针的a。

返回值：无

mln_http_get_status
mln_http_get_status(h)

描述：获取类型为mln_http_t的h中响应状态字，例如200 400等。

返回值：整型状态字

mln_http_set_status
mln_http_set_status(h,s)

描述：将mln_http_t类型的h中响应状态字设置为整型的s。

返回值：无

mln_http_get_method
mln_http_get_method(h)

描述：获取类型为mln_http_t的h中方法字段

返回值：

  • M_HTTP_GET
  • M_HTTP_POST
  • M_HTTP_HEAD
  • M_HTTP_PUT
  • M_HTTP_DELETE
  • M_HTTP_TRACE
  • M_HTTP_CONNECT
  • M_HTTP_OPTIONS
mln_http_set_method
mln_http_set_method(h,m)

描述：将mln_http_t类型的h中请求方法设置为m，m的可用值参考mln_http_get_method的返回值部分。

返回值：无

mln_http_get_version
mln_http_get_version(h)

描述：获取类型为mln_http_t的h中HTTP版本

返回值：

  • M_HTTP_VERSION_1_0 HTTP 1.0
  • M_HTTP_VERSION_1_1 HTTP 1.1
mln_http_set_version
mln_http_set_version(h,v)

描述：将mln_http_t类型的h中的HTTP版本号为v，v的取值参考mln_http_get_version的返回值。

返回值：无

mln_http_get_type
mln_http_get_type(h)

描述：获取类型为mln_http_t的h中HTTP类型，即请求还是响应。

返回值：

  • M_HTTP_UNKNOWN未知类型
  • M_HTTP_REQUEST请求
  • M_HTTP_RESPONSE响应
mln_http_set_type
mln_http_set_type(h,t)

描述：将mln_http_t类型的h中报文类型设置为t，t的取值参考mln_http_get_type的返回值。

返回值：无

mln_http_get_handler
mln_http_get_handler(h)

描述：获取类型为mln_http_t的h中体处理函数指针。

返回值：类型为mln_http_handler的函数指针

mln_http_set_handler
mln_http_set_handler(h,hlr)

描述：将mln_http_t类型的h中提处理函数设置为mln_http_handler类型的hlr。

返回值：无

mln_http_get_response_msg
mln_http_get_response_msg(h)

描述：获取类型为mln_http_t的h中响应信息，即类似：Bad Request 或 Internal Server Error等字符串。

返回值：mln_string_t类型指针

mln_http_set_response_msg
mln_http_set_response_msg(h,m)

描述：将mln_http_t类型的h中响应信息设置为mln_string_t类型指针的m。

返回值：无

mln_http_get_error
mln\_http\_get\_error(h)

#define M\_HTTP\_CONTINUE 100
#define M\_HTTP\_SWITCHING\_PROTOCOLS 101
#define M\_HTTP\_PROCESSING 102
#define M\_HTTP\_OK 200
#define M\_HTTP\_CREATED 201
#define M\_HTTP\_ACCEPTED 202
#define M\_HTTP\_NON\_AUTHORITATIVE\_INFORMATION 203
#define M\_HTTP\_NO\_CONTENT 204
#define M\_HTTP\_RESET\_CONTENT 205
#define M\_HTTP\_PARTIAL\_CONTENT 206
#define M\_HTTP\_MULTI\_STATUS 207
#define M\_HTTP\_MULTIPLE\_CHOICES 300
#define M\_HTTP\_MOVED\_PERMANENTLY 301
#define M\_HTTP\_MOVED\_TEMPORARILY 302
#define M\_HTTP\_SEE\_OTHER 303
#define M\_HTTP\_NOT\_MODIFIED 304
#define M\_HTTP\_USE\_PROXY 305
#define M\_HTTP\_SWITCH\_PROXY 306
#define M\_HTTP\_TEMPORARY\_REDIRECT 307
#define M\_HTTP\_BAD\_REQUEST 400
#define M\_HTTP\_UNAUTHORIZED 401
#define M\_HTTP\_PAYMENT\_REQUIRED 402
#define M\_HTTP\_FORBIDDEN 403
#define M\_HTTP\_NOT\_FOUND 404
#define M\_HTTP\_METHOD\_NOT\_ALLOWED 405
#define M\_HTTP\_NOT\_ACCEPTABLE 406
#define M\_HTTP\_PROXY\_AUTHENTICATION\_REQUIRED 407
#define M\_HTTP\_REQUEST\_TIMEOUT 408
#define M\_HTTP\_CONFLICT 409
#define M\_HTTP\_GONE 410
#define M\_HTTP\_LENGTH\_REQUIRED 411
#define M\_HTTP\_PRECONDITION\_FAILED 412
#define M\_HTTP\_REQUEST\_ENTITY\_TOO\_LARGE 413
#define M\_HTTP\_REQUEST\_URI\_TOO\_LARGE 414
#define M\_HTTP\_UNSUPPORTED\_MEDIA\_TYPE 415
#define M\_HTTP\_REQUESTED\_RANGE\_NOT\_SATISFIABLE 416
#define M\_HTTP\_EXPECTATION\_FAILED 417
#define M\_HTTP\_TOO\_MANY\_CONNECTIONS 421
#define M\_HTTP\_UNPROCESSABLE\_ENTITY 422
#define M\_HTTP\_LOCKED 423
#define M\_HTTP\_FAILED\_DEPENDENCY 424
#define M\_HTTP\_UNORDERED\_COLLECTION 425
#define M\_HTTP\_UPGRADE\_REQUIRED 426
#define M\_HTTP\_RETRY\_WITH 449
#define M\_HTTP\_INTERNAL\_SERVER\_ERROR 500
#define M\_HTTP\_NOT\_IMPLEMENTED 501
#define M\_HTTP\_BAD\_GATEWAY 502
#define M\_HTTP\_SERVICE\_UNAVAILABLE 503
#define M\_HTTP\_GATEWAY\_TIMEOUT 504
#define M\_HTTP\_VERSION\_NOT\_SUPPORTED 505
#define M\_HTTP\_VARIANT\_ALSO\_NEGOTIATES 506
#define M\_HTTP\_INSUFFICIENT\_STORAGE 507
#define M\_HTTP\_BANDWIDTH\_LIMIT\_EXCEEDED 509
#define M\_HTTP\_NOT\_EXTENDED 510
#define M\_HTTP\_UNPARSEABLE\_RESPONSE\_HEADERS 600

描述：获取类型为mln_http_t的h中错误信息。

返回值：宏定义的错误值

mln_http_set_error
mln_http_set_error(h,e)

描述：将mln_http_t类型的h中错误信息设置为e，e的取值参见mln_http_get_error中的宏定义。

返回值：无

mln_http_get_header
mln_http_get_header(h)

描述：获取类型为mln_http_t的h中头字段结构。

返回值：mln_hash_t类型结构

示例
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include "mln\_core.h"
#include "mln\_log.h"
#include "mln\_http.h"
#include "mln\_file.h"


static void mln\_accept(mln_event_t \*ev, int fd, void \*data);
static int mln\_http\_recv\_body\_handler(mln_http_t \*http, mln_chain_t \*\*in, mln_chain_t \*\*nil);
static void mln\_recv(mln_event_t \*ev, int fd, void \*data);
static void mln\_quit(mln_event_t \*ev, int fd, void \*data);
static void mln\_send(mln_event_t \*ev, int fd, void \*data);
static int mln\_http\_send\_body\_handler(mln_http_t \*http, mln_chain_t \*\*body_head, mln_chain_t \*\*body_tail);

static void worker\_process(mln_event_t \*ev)
{
    mln_u16_t port = 1234;
    mln_s8_t ip[] = "0.0.0.0";
    struct sockaddr_in addr;
    int val = 1;
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        mln\_log(error, "listen socket error\n");
        return;
    }
    if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
        mln\_log(error, "setsockopt error\n");
        close(listenfd);
        return;
    }
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet\_addr(ip);
    if (bind(listenfd, (struct sockaddr \*)&addr, sizeof(addr)) < 0) {
        mln\_log(error, "bind error\n");
        close(listenfd);
        return;
    }
    if (listen(listenfd, 511) < 0) {
        mln\_log(error, "listen error\n");
        close(listenfd);
        return;
    }

    if (mln\_event\_set\_fd(ev, \
                         listenfd, \
                         M_EV_RECV|M_EV_NONBLOCK, \
                         M_EV_UNLIMITED, \
                         NULL, \
                         mln_accept) < 0)
    {
        mln\_log(error, "listen sock set event error\n");
        close(listenfd);
        return;
    }
}

static void mln\_accept(mln_event_t \*ev, int fd, void \*data)
{
    mln_tcp_conn_t \*connection;
    mln_http_t \*http;
    int connfd;
    socklen_t len;
    struct sockaddr_in addr;

    while (1) {
        memset(&addr, 0, sizeof(addr));
        len = sizeof(addr);
        connfd = accept(fd, (struct sockaddr \*)&addr, &len);
        if (connfd < 0) {
            if (errno == EAGAIN) break;
            if (errno == EINTR) continue;
            perror("accept");
            exit(1);
        }

        connection = (mln_tcp_conn_t \*)malloc(sizeof(mln_tcp_conn_t));
        if (connection == NULL) {
            fprintf(stderr, "3No memory.\n");
            close(connfd);
            continue;
        }
        if (mln\_tcp\_conn\_init(connection, connfd) < 0) {
            fprintf(stderr, "4No memory.\n");
            close(connfd);
            free(connection);
            continue;
        }

        http = mln\_http\_init(connection, NULL, mln_http_recv_body_handler);
        if (http == NULL) {
            fprintf(stderr, "5No memory.\n");
            mln\_tcp\_conn\_destroy(connection);
            free(connection);
            close(connfd);
            continue;
        }

        if (mln\_event\_set\_fd(ev, \
                             connfd, \
                             M_EV_RECV|M_EV_NONBLOCK, \
                             M_EV_UNLIMITED, \
                             http, \
                             mln_recv) < 0)
        {
            fprintf(stderr, "6No memory.\n");
            mln\_http\_destroy(http);
            mln\_tcp\_conn\_destroy(connection);
            free(connection);
            close(connfd);
            continue;
        }
    }
}

static void mln\_quit(mln_event_t \*ev, int fd, void \*data)
{
    mln_http_t \*http = (mln_http_t \*)data;
    mln_tcp_conn_t \*connection = mln\_http\_get\_connection(http);

    mln\_event\_set\_fd(ev, fd, M_EV_CLR, M_EV_UNLIMITED, NULL, NULL);
    mln\_http\_destroy(http);
    mln\_tcp\_conn\_destroy(connection);
    free(connection);
    close(fd);
}

static void mln\_recv(mln_event_t \*ev, int fd, void \*data)
{
    mln_http_t \*http = (mln_http_t \*)data;
    mln_tcp_conn_t \*connection = mln\_http\_get\_connection(http);
    int ret, rc;
    mln_chain_t \*c;

    while (1) {
        ret = mln\_tcp\_conn\_recv(connection, M_C_TYPE_MEMORY);
        if (ret == M_C_FINISH) {
            continue;
        } else if (ret == M_C_NOTYET) {
            c = mln\_tcp\_conn\_remove(connection, M_C_RECV);
            if (c != NULL) {
                rc = mln\_http\_parse(http, &c);
                if (c != NULL) {
                    mln\_tcp\_conn\_append\_chain(connection, c, NULL, M_C_RECV);
                }
                if (rc == M_HTTP_RET_OK) {
                    return;
                } else if (rc == M_HTTP_RET_DONE) {
                    mln\_send(ev, fd, data);
                } else {
                    fprintf(stderr, "Http parse error. error\_code:%u\n", mln\_http\_get\_error(http));
                    mln\_quit(ev, fd, data);
                    return;
                }
            }
            break;
        } else if (ret == M_C_CLOSED) {
            c = mln\_tcp\_conn\_remove(connection, M_C_RECV);
            if (c != NULL) {
                rc = mln\_http\_parse(http, &c);
                if (c != NULL) {
                    mln\_tcp\_conn\_append\_chain(connection, c, NULL, M_C_RECV);
                }
                if (rc == M_HTTP_RET_ERROR) {
                    fprintf(stderr, "Http parse error. error\_code:%u\n", mln\_http\_get\_error(http));
                }
            }
            mln\_quit(ev, fd, data);
            return;
        } else if (ret == M_C_ERROR) {
            mln\_quit(ev, fd, data);
            return;
        }
    }
}

static int mln\_http\_recv\_body\_handler(mln_http_t \*http, mln_chain_t \*\*in, mln_chain_t \*\*nil)
{
    mln_u32_t method = mln\_http\_get\_method(http);
    if (method == M_HTTP_GET)
        return M_HTTP_RET_DONE;
    mln\_http\_set\_error(http, M_HTTP_NOT_IMPLEMENTED);
    return M_HTTP_RET_ERROR;
}

static void mln\_send(mln_event_t \*ev, int fd, void \*data)
{
    mln_http_t \*http = (mln_http_t \*)data;
    mln_tcp_conn_t \*connection = mln\_http\_get\_connection(http);
    mln_chain_t \*c = mln\_tcp\_conn\_get\_head(connection, M_C_SEND);
    int ret;

    if (c == NULL) {
        mln\_http\_reset(http);
        mln\_http\_set\_status(http, M_HTTP_OK);
        mln\_http\_set\_version(http, M_HTTP_VERSION_1_0);
        mln\_http\_set\_type(http, M_HTTP_RESPONSE);
        mln\_http\_set\_handler(http, mln_http_send_body_handler);
        mln_chain_t \*body_head = NULL, \*body_tail = NULL;
        if (mln\_http\_generate(http, &body_head, &body_tail) == M_HTTP_RET_ERROR) {
            fprintf(stderr, "mln\_http\_generate() failed. %u\n", mln\_http\_get\_error(http));
            mln\_quit(ev, fd, data);
            return;
        }
        mln\_tcp\_conn\_append\_chain(connection, body_head, body_tail, M_C_SEND);
    }

    while ((c = mln\_tcp\_conn\_get\_head(connection, M_C_SEND)) != NULL) {
        ret = mln\_tcp\_conn\_send(connection);
        if (ret == M_C_FINISH) {
            mln\_quit(ev, fd, data);
            break;
        } else if (ret == M_C_NOTYET) {
            mln\_chain\_pool\_release\_all(mln\_tcp\_conn\_remove(connection, M_C_SENT));
            mln\_event\_set\_fd(ev, fd, M_EV_SEND|M_EV_APPEND|M_EV_NONBLOCK, M_EV_UNLIMITED, data, mln_send);
            return;
        } else if (ret == M_C_ERROR) {
            mln\_quit(ev, fd, data);
            return;
        } else {
            fprintf(stderr, "Shouldn't be here.\n");
            abort();
        }
    }
}

static int mln\_http\_send\_body\_handler(mln_http_t \*http, mln_chain_t \*\*body_head, mln_chain_t \*\*body_tail)
{
    mln_u8ptr_t buf;
    mln_alloc_t \*pool = mln\_http\_get\_pool(http);
    mln_string_t cttype_key = mln\_string("Content-Type");
    mln_string_t cttype_val = mln\_string("text/html");

    buf = mln\_alloc\_m(pool, 5);
    if (buf == NULL) {
        mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
        return M_HTTP_RET_ERROR;
    }
    memcpy(buf, "hello", 5);

    if (mln\_http\_set\_field(http, &cttype_key, &cttype_val) == M_HTTP_RET_ERROR) {
        mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
        return M_HTTP_RET_ERROR;
    }

    mln_string_t ctlen_key = mln\_string("Content-Length");
    mln_string_t ctlen_val = mln\_string("5");
    if (mln\_http\_set\_field(http, &ctlen_key, &ctlen_val) == M_HTTP_RET_ERROR) {
        mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
        return M_HTTP_RET_ERROR;
    }

    mln_chain_t \*c = mln\_chain\_new(pool);
    if (c == NULL) {
        mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
        return M_HTTP_RET_ERROR;
    }
    mln_buf_t \*b = mln\_buf\_new(pool);
    if (b == NULL) {
        mln\_chain\_pool\_release(c);
        mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
        return M_HTTP_RET_ERROR;
    }
    c->buf = b;
    b->left_pos = b->pos = b->start = buf;
    b->last = b->end = buf + 5;
    b->in_memory = 1;
    b->last_buf = 1;
    b->last_in_chain = 1;

    if (\*body_head == NULL) {
        \*body_head = \*body_tail = c;
    } else {
        (\*body_tail)->next = c;
        \*body_tail = c;
    }

    return M_HTTP_RET_DONE;
}

int main(int argc, char \*argv[])
{
    struct mln_core_attr cattr;

    cattr.argc = argc;
    cattr.argv = argv;
    cattr.global_init = NULL;
    cattr.worker_process = worker_process;
    return mln\_core\_init(&cattr);
}

矩阵运算

头文件
#include "mln_matrix.h"
相关结构
typedef struct {                 
    mln_size_t  row;//矩阵的行数
    mln_size_t  col;//矩阵的列数
    double     *data;//一个一维数组，包含了矩阵内所有元素，按行一次排列
    mln_u32_t   is_ref:1;//标识data是否为外部引用，该标记用于释放矩阵结构时忽略对data的释放
} mln_matrix_t;
函数
mln_matrix_new
mln_matrix_t *mln_matrix_new(mln_size_t row, mln_size_t col, double *data, mln_u32_t is_ref);

描述：创建一个row行col列，数据为data的矩阵。若is_ref为0则表示矩阵结构会完全复制一个data在其中，否则直接引用data。

返回值：成功则返回矩阵结构指针，否则返回NULL

mln_matrix_free
void mln_matrix_free(mln_matrix_t *matrix);

描述：释放矩阵结构内存。

返回值：无

mln_matrix_mul
mln_matrix_t *mln_matrix_mul(mln_matrix_t *m1, mln_matrix_t *m2);

描述：矩阵乘法。

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

t *pool = mln_http_get_pool(http);
mln_string_t cttype_key = mln_string(“Content-Type”);
mln_string_t cttype_val = mln_string(“text/html”);

buf = mln\_alloc\_m(pool, 5);
if (buf == NULL) {
    mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
    return M_HTTP_RET_ERROR;
}
memcpy(buf, "hello", 5);

if (mln\_http\_set\_field(http, &cttype_key, &cttype_val) == M_HTTP_RET_ERROR) {
    mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
    return M_HTTP_RET_ERROR;
}

mln_string_t ctlen_key = mln\_string("Content-Length");
mln_string_t ctlen_val = mln\_string("5");
if (mln\_http\_set\_field(http, &ctlen_key, &ctlen_val) == M_HTTP_RET_ERROR) {
    mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
    return M_HTTP_RET_ERROR;
}

mln_chain_t \*c = mln\_chain\_new(pool);
if (c == NULL) {
    mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
    return M_HTTP_RET_ERROR;
}
mln_buf_t \*b = mln\_buf\_new(pool);
if (b == NULL) {
    mln\_chain\_pool\_release(c);
    mln\_http\_set\_error(http, M_HTTP_INTERNAL_SERVER_ERROR);
    return M_HTTP_RET_ERROR;
}
c->buf = b;
b->left_pos = b->pos = b->start = buf;
b->last = b->end = buf + 5;
b->in_memory = 1;
b->last_buf = 1;
b->last_in_chain = 1;

if (\*body_head == NULL) {
    \*body_head = \*body_tail = c;
} else {
    (\*body_tail)->next = c;
    \*body_tail = c;
}

return M_HTTP_RET_DONE;

}

int main(int argc, char *argv[])
{
struct mln_core_attr cattr;

cattr.argc = argc;
cattr.argv = argv;
cattr.global_init = NULL;
cattr.worker_process = worker_process;
return mln\_core\_init(&cattr);

}


### 矩阵运算


#### 头文件

#include “mln_matrix.h”


#### 相关结构

typedef struct {
mln_size_t row;//矩阵的行数
mln_size_t col;//矩阵的列数
double *data;//一个一维数组，包含了矩阵内所有元素，按行一次排列
mln_u32_t is_ref:1;//标识data是否为外部引用，该标记用于释放矩阵结构时忽略对data的释放
} mln_matrix_t;


#### 函数


##### mln\_matrix\_new

mln_matrix_t *mln_matrix_new(mln_size_t row, mln_size_t col, double *data, mln_u32_t is_ref);


描述：创建一个`row`行`col`列，数据为`data`的矩阵。若`is_ref`为`0`则表示矩阵结构会完全复制一个`data`在其中，否则直接引用`data`。


返回值：成功则返回矩阵结构指针，否则返回`NULL`


##### mln\_matrix\_free

void mln_matrix_free(mln_matrix_t *matrix);


描述：释放矩阵结构内存。


返回值：无


##### mln\_matrix\_mul

mln_matrix_t *mln_matrix_mul(mln_matrix_t *m1, mln_matrix_t *m2);


描述：矩阵乘法。




[外链图片转存中...(img-nEwXyAon-1715534546972)]
[外链图片转存中...(img-3yNhKcUk-1715534546972)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84925558
关注
专栏目录
【C语言开源库】C语言必备实用第三方库Melon(包括数据结构算法)
qq_41854911的博客
08-01 8764
简介 Melon 是一个用于简化开发的 C 框架库。 它包括许多数据结构、算法、体系结构和许多其他有用的组件。 您可以根据自己的需求选择一些组件或整个框架。 Melon 通过模块开发支持多进程和多线程模型。 在 Windows 上，框架无法激活，但其他组件仍在工作。 melon GitHub地址：Melon melon中文帮助文档：中文手册 安装 Windows与UNIX环境的安装并无差异，仅需要先行安装并配置mingw、git bash以及make即可。 执行如下命令安装Melon： $ git clon
2024华为OD机试真题目录 B+C+D+E卷，使用C语言进行解答（484道）
热门推荐
KJ.JK
04-15 14万+
本文是华为OD机试真题(C语言)专栏的目录贴（持续更新中…）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习华为OD机试真题(C语言）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习。
【C语言开源库】C语言必备实用第三方库Melon(包括数据结构算法)_c melon(1)
youpwwcc的博客
04-15 1092
这里设置的字符串必须是从内存池或堆中分配的内存，栈中内存会出现段错误，因为赋值时不会在宏内自动复制一份而是直接使用。中的任意一个字符时都会被进行分割，连续遇到多个时仅分割一次，且分割后，分隔符不会出现在被分割后的字符串中。：是入栈数据的释放函数，由于入栈数据可能为自定义数据结构，因此若需释放，可对此进行设置否则置。节点设置类型，依次分别为：无类型、对象、数组、字符串、数字、布尔真、布尔假、NULL。
c语言数据结构
最新发布
cuitlse的博客
07-31 886
单链表的第一个结点也称为首结点，它的地址可以通过链表的头指针head找到，其他结点的地址通过前驱结点的link域名找到，链表的最后一个结点没有后继，则在link域放一个空指针NULL，图中用“^”表示。线性表中的数据元素的顺序与器链表表示中的物理顺序可能不一致，一般通过但链表的指针将各个数据元素按照线性表的逻辑顺序链接起来。核心思想：选择排序法是从排序的元素中宣传最小的一个元素和第一元素交换位置，然后从剩下的元素中选出最小的元素和第二个元素交换，重复这种处理的方法，直到最后一个元素为止。
Linux自主学习 - C语言库Melon的快速入门
qq_66095714的博客
06-30 929
Linux自主学习 - C语言库Melon的快速入门
开源C语言库Melon：用户态动态追踪与控制反馈
weixin_40960130的博客
02-03 424
本文介绍基于Melon的动态追踪技术，让程序在用户态内完成对自身的动态追踪，而不依赖于内核态，也不依赖于uprobe和usdt等内容。
华为OD机试真题目录汇总（C语言）2024 B+C+D+E卷 （484道）
KJ.JK
08-09 8万+
本文是华为OD机试真题（C语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
【C语言题解】华为 OD 机试 C卷抽中题库清单（全真题库）含考点说明
算法大师！
01-13 724
目前在考C卷，经过两个月的收集整理，C卷真题已基本整理完毕抽到原题的概率为2/3到3/3，也就是最少抽到两道原题。请注意：大家刷完C卷真题，最好要把B卷的真题刷一下，因为C卷的部分真题来自B卷。
C语言实用第三方库Melon开箱即用之多线程模型
weixin_40960130的博客
02-15 982
本文转载自本人头条号：https://www.toutiao.com/i6928959491274703371/ 转载请注明出处，感谢！ 在之前的文章中（开发利器——C 语言必备实用第三方库），笔者介绍了一款Linux/UNIX下C语言库Melon的基本功能，并给出了一个简单的多进程开箱即用的例子。 本文将给大家介绍Melon中多线程的使用方法。 之前的文章中提到过，在Melon中有两种多线程模式： 模块化的多线程模式 线程池 我们将逐一给出实例。 Melon的Github仓库：https://g.
一个开源的Ftp库，C语言实现，有例程
07-16
LibNcFTP是一个开源的FTP源码库，该库用C语言实现的，可以灵活应用在自己的应用上，非常简单好用。附带一个测试例程
cstl--国人写的挺不错的C语言通用数据结构和常用算法库，支持一个
06-20
cstl是使用C语言编写的一个通用的数据结构和常用的算法库，它模仿SGI STL的接口和实现，支持vector, list, deque等等常用的数据结构，同时还支持排序，查找，划分等常用的算法，此外cstl也包含迭代器的类型，它作为容器和算法之间的桥梁。cstl为C语言编程中的数据管理提供了便利。 有兴趣的可以去libcstl.googlecode.com看看
有价值的C语言开源库
z444_579的博客
08-15 2193
- 1. Webbench Webbench是一个在linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力下工作的性能，最多可以模拟3万个并发连接去测试网站的负载能力。Webbench使用C语言编写, 代码实在太简洁，源码加起来不到600行。 下载链接：http://home.tiscali.cz/~cz210552/webb
C语言第三方库Melon开箱即用之词法分析器使用
weixin_40960130的博客
02-15 888
之前的文章中，笔者介绍了Linux/UNIX C语言库Melon的基本功能及框架使用。 本文将介绍Melon中的词法分析器组件。 Melon的Github仓库为：https://github.com/Water-Melon/Melon 词法分析器在Melon中并不依赖于自身框架，因此可以在不初始化框架的情况下即可使用。 基础使用 我们先来看一个基本例子： //lexer.c #include <stdio.h> #include "mln_lex.h" MLN_DEFINE_TOKEN_T
开源C语言库Melon：多线程治理
weixin_40960130的博客
01-29 588
不知你是否有过类似如下的需求： 有一些功能，它们足够单一，但又需要后台持续运行，以容器实现感觉太重了，以进程实现又太琐碎了，以线程实现可以接受但是又不好管理。
C语言第三方库---Melon安装（Linux）
Erictr的博客
12-07 2353
C语言第三方库—Melon安装（Linux） Melon库是C语言开发时常用的一个第三方库，内部包含了一些常用的数据结构和算法，因为C语言标准库中没有像C++或者Java里的一些强大的库，最近想深入学习更多C语言，下面也是自己学习记录的过程 ： 这里使用的是Ubuntu20.04，首先你的Linux需要先安装好git，make等工具，既然你要安装第三方库，这里默认你已经安装过一些必要的软件了。 使用git命从GitHub下载melon： git clone https://github.com/water-
17个C语言常用第三方库的总结
极客代码
01-25 2231
OpenSSL: 开源加密算法库，使用C语言编写，支持多种操作系统，提供多种加密算法实现和SSL/TLS协议支持。- FLTK: 轻量级跨平台图形界面库，使用C++语言编写，支持多种操作系统，提供基本的控件和主题。- Crypto++: 开源加密算法库，使用C++语言编写，支持多种操作系统，提供多种加密算法实现。- GTK+: 跨平台开源图形界面库，使用C语言编写，支持多种操作系统，提供丰富的控件和主题。- Qt: 跨平台开源图形界面库，使用C++语言编写，支持多种操作系统，提供丰富的控件和主题。
请用c++写一个wordle拼字游戏的实现
08-12
好的，这里是一个用 C 语言实现的 Wordle 拼字游戏的例子。 首先，我们需要一个字典来存储单词列表。可以使用数组或链表来实现。这里我们使用数组。 ``` #define MAX_WORDS 100000 char dictionary[MAX_WORDS][MAX...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值