标签：node int 系统 最终 list next void unit 度量

#ifndef LIST_H_
#define LIST_H_

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

#define FAILURE                                             (-1)
#define SUCCESS                                             (0)
#define RETURN_VALUE_IF_FAILED(expr, val)                   do { if (!(expr)) { return val; }} while (0)
#define MALLOC(n, type)                                     ( (type*)malloc( (n)*sizeof(type) ) )

/* 链表节点封装 */
typedef struct node{
    void *datap;
    struct node *prev;
    struct node *next;
} node_t;

/* 链表类型封装 */
typedef struct list {
    int     n;       ///<   链表中节点的个数
    int     size;    ///<   链表节点中存放数据的空间大小
    node_t  head;    ///<   链表的头节点
} list_t;

/* 回调函数类型定义 */
typedef int compare_t(void *data1, void *data2);

/* 初始化链表 */
list_t *init_list(int size);

/* 新建一个节点 */
// node_t *create_node(int size);

/* 插入节点 */
void insert_node(node_t *prev_node, node_t *next_node, node_t *new_node);

/* 头部插入节点 */
int append_node_top(list_t *list, void *data);

/* 尾部插入节点 */
int append_node_tail(list_t *list, void *data);

/* 排序插入节点 */
int sort_insert(list_t *list, compare_t *func, void *data);

/* 条件查找节点,匹配第一个 */
void *search_node_by_item(list_t *list, compare_t *func, void *item);

/* 条件查找节点,匹配所有 */
list_t *search_nodes_by_item(list_t *list, compare_t *func, void *item);

/* 删除符合条件的第一个节点 */
int delete_node_by_item(list_t *list, compare_t *func, void *item);

/* 删除符合条件的所有节点 */
int delete_nodes_by_item(list_t *list, compare_t *func, void *item);

/* 链表排序 */
void sort_list(list_t *list, compare_t *func);

/* 前向遍历链表 */
void traverse_list_forward(list_t *list, void (*func)(void *data));

/* 后向遍历链表 */
void traverse_list_backward(list_t *list, void (*func)(void *data));

/* 判断链表是否为空 */
int is_list_empty(list_t *list);

/* 销毁链表 */
void destory_list(list_t *list);

#endif // !LIST_H_

#include "slist.h"

/* 初始化链表 */
list_t *init_list(int size) {
    list_t *temp;

    /* 分配链表空间 */
    temp = (list_t *)malloc(sizeof(list_t));
    RETURN_VALUE_IF_FAILED(NULL != temp, NULL);

    /* 初始化链表 */
    temp->size = size;
    temp->n = 0;
    temp->head.next = &temp->head;
    temp->head.prev = &temp->head;
    return temp;
}

/* 新建一个节点 */
static node_t *create_node(int size) {
    node_t *new_node = MALLOC(sizeof(node_t), node_t);
    RETURN_VALUE_IF_FAILED(NULL != new_node, NULL);
    new_node->datap = MALLOC(size, void);
    RETURN_VALUE_IF_FAILED(NULL != new_node->datap, NULL);
    return new_node;
}

/* 插入节点 */
void insert_node(node_t *prev_node, node_t *next_node, node_t *new_node) {
    new_node->next = next_node;
    new_node->prev = prev_node;
    prev_node->next = new_node;
    next_node->prev = new_node;
}

/* 头部插入节点 */
int append_node_top(list_t *list, void *data) {
    node_t *new_node = create_node(list->size);
    RETURN_VALUE_IF_FAILED(NULL != new_node, FAILURE);
    memmove(new_node->datap, data, list->size);
    insert_node(&list->head, list->head.next, new_node);
    list->n += 1;
    return SUCCESS;
}

/* 尾部插入节点 */
int append_node_tail(list_t *list, void *data) {
    node_t *new_node = create_node(list->size);
    RETURN_VALUE_IF_FAILED(NULL != new_node, FAILURE);
    memmove(new_node->datap, data, list->size);
    insert_node(list->head.prev, &list->head, new_node);
    list->n += 1;
    return SUCCESS;
}

/* 排序插入节点 */
int sort_insert(list_t *list, compare_t *func, void *data) {
    node_t *new_node = create_node(list->size);
    RETURN_VALUE_IF_FAILED(NULL != new_node, FAILURE);
    memmove(new_node->datap, data, list->size);
    node_t *i;
    for (i = list->head.next; i != &list->head; i = i->next) {
        if (func(i->datap, data) >= 0) {
            break;
        }
    }
    insert_node(i->prev, i, new_node);
    list->n += 1;
    return SUCCESS;
}

/* 条件查找节点,匹配第一个 */
void *search_node_by_item(list_t *list, compare_t *func, void *item) {
    node_t *i;
    i = list->head.next;
    while (i != &list->head) {
        if (func(i->datap, item) == 1) {
            return i->datap;
        }
        i = i->next;
    }
    return NULL;
}

/* 条件查找节点,匹配所有 */
list_t *search_nodes_by_item(list_t *list, compare_t *func, void *item) {
    list_t *result;
    node_t *i;

    result = init_list(list->size);
    RETURN_VALUE_IF_FAILED(NULL != result, NULL);
    i = list->head.next;
    while (i != &list->head) {
        if (func(i->datap, item) == 1) {
            append_node_tail(result, i->datap);
        }
        i = i->next;
    }
    return result;
}

/* 删除符合条件的第一个节点 */
int delete_node_by_item(list_t *list, compare_t *func, void *item) {
    node_t *i = list->head.next;

    while (i != &list->head) {
        if (func(i->datap, item) == 1) {
            i->next->prev = i->prev;
            i->prev->next = i->next;
            free(i->datap);
            free(i);
            list->n -= 1;
            return 0;
        }
        i = i->next;
    }
    return FAILURE;
}

/* 删除符合条件的所有节点 */
int delete_nodes_by_item(list_t *list, compare_t *func, void *item) {
    int count = 0;
    node_t *i, *next;

    i = list->head.next;
    while (i != &list->head) {
        if (func(i->datap, item) == 1) {
            next = i->next;
            i->next->prev = i->prev;
            i->prev->next = i->next;
            free(i->datap);
            free(i);
            list->n -= 1;
            count++;
            i = next;
            continue;
        }
        i = i->next;
    }
    return count;
}

/* 链表排序 */
void sort_list(list_t *list, compare_t *func) {
    node_t *i, *j;
    void *temp;

    for (i = list->head.next; i != &list->head; i = i->next) {
        for (j = i->next; j != &list->head; j = j->next) {
            if (func(i->datap, j->datap) == 1) {
                temp = i->datap;
                i->datap = j->datap;
                j->datap = temp;
            }
        }
    }
}

/* 前向遍历链表 */
void traverse_list_forward(list_t *list, void (*func)(void *data)) {
    node_t *i;
    for (i = list->head.next; i != &list->head; i = i->next) {
        func(i->datap);
    }
}

/* 后向遍历链表 */
void traverse_list_backward(list_t *list, void (*func)(void *data)) {
    node_t *i;
    for (i = list->head.prev; i != &list->head; i = i->prev) {
        func(i->datap);
    }
}

/* 判断链表是否为空 */
int is_list_empty(list_t *list) {
    return list->head.next == &list->head && list->head.prev == &list->head;
}

/* 销毁链表 */
void destory_list(list_t *list) {
    node_t *i, *next;
    i = list->head.next;
    while (i != &list->head) {
        next = i->next;
        free(i->datap);
        free(i);
        i = next;
    }
    free(list);
}

#ifndef DIMENSION_H_
#define DIMENSION_H_

#include "slist.h"

/* 量纲类型 */
typedef struct {
    char         name[32];
    unsigned int conversion;
    // unsigned int value;
}dimension_t;

/* 实例，继承量纲信息 */
typedef struct {
    dimension_t unit_info;
    unsigned int value;
}dim_inst_t;

typedef struct {
    dimension_t           unit_info;
    list_t*               unit_list;
    // unit_register_fun     unit_register;
}dim_init_table_t;

/* 构造一个度量单位列表 */
list_t *struct_a_unit_list(void);

int register_unit(char *name, unsigned int conversion, list_t *unit_list);

int register_dim_init_table(dim_init_table_t *dim_init_table, int size);

void printf_dimension(dimension_t *datap);

#endif // !DIMENSION_H_

#include "dimension.h"

list_t *struct_a_unit_list(void) {
    list_t *temp = init_list(sizeof(dimension_t));
    return temp;
}

void printf_dimension(dimension_t *datap) {
    printf("name      :%s\n", datap->name);
    printf("conversion:%d\n", datap->conversion);
    // printf("value     :%d\n", datap->value);
}

static dimension_t *struct_a_unit(char *name, unsigned int conversion) {
    dimension_t *temp = MALLOC(sizeof(dimension_t), dimension_t);
    RETURN_VALUE_IF_FAILED(NULL != temp, NULL);
    RETURN_VALUE_IF_FAILED(NULL != name, NULL);
    memcpy(temp->name, name, sizeof(temp->name));
    temp->conversion = conversion;
    return temp;
}

int register_unit(char *name, unsigned int conversion, list_t *unit_list) {
    dimension_t *temp = struct_a_unit(name, conversion);
    if (NULL == temp || SUCCESS != append_node_tail(unit_list, temp)) {
        return FAILURE;
    }
    return SUCCESS;
}

int register_dim_init_table(dim_init_table_t *dim_init_table, int size) {
    int i;
    RETURN_VALUE_IF_FAILED(NULL != dim_init_table, FAILURE);
    RETURN_VALUE_IF_FAILED(0     < size,           FAILURE);
    printf("size:%d\n", size);
    for (i = 0; i < size; i++) {
        register_unit(
            dim_init_table[i].unit_info.name, 
            dim_init_table[i].unit_info.conversion,
            dim_init_table[i].unit_list);
    }
    return SUCCESS;
}

#include "dimension.h"
#include "slist.h"

int main(void) {



    /* 创建一个保存单位类型的链表并初始化*/
    list_t *len_unit_list = struct_a_unit_list();
    RETURN_VALUE_IF_FAILED(NULL != len_unit_list, FAILURE);

    list_t *vol_unit_list = struct_a_unit_list();
    RETURN_VALUE_IF_FAILED(NULL != vol_unit_list, FAILURE);

    dim_init_table_t dim_init_table[] = {
        /* 长度系统度量类型 */
        {{"Base", 1},         len_unit_list},
        {{"Inch", 1},         len_unit_list},
        {{"Feet", 12},        len_unit_list},
        {{"Yard", 12*3},      len_unit_list},
        {{"Mile", 1760*12*3}, len_unit_list},
        /* 体积系统度量类型 */
        {{"Base", 1},         vol_unit_list},
        {{"TSP",  1},         vol_unit_list},
        {{"TBSP", 12},        vol_unit_list},
        {{"OZ",   12*3},      vol_unit_list},
    };

    /* 注册以上度量单位 */

    RETURN_VALUE_IF_FAILED(
        FAILURE != register_dim_init_table(dim_init_table, sizeof(dim_init_table)/sizeof(dim_init_table_t)), 
        FAILURE);

    /* 遍历打印链表 */
    traverse_list_backward(len_unit_list, printf_dimension);
    traverse_list_backward(vol_unit_list, printf_dimension);

    destory_list(len_unit_list);
    destory_list(vol_unit_list);
}

标签：node,int,系统,最终,list,next,void,unit,度量
来源： https://blog.csdn.net/qq_21311911/article/details/117601591

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。