链式线性表C模版库编程(解耦合)思想的实现

最新推荐文章于 2023-01-06 11:03:26 发布
最新推荐文章于 2023-01-06 11:03:26 发布
阅读量260 收藏 1
点赞数
分类专栏： 数据结构 Linux基础 C编程典型习题案例集 文章标签： C数据结构模版库 解耦合思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43142013/article/details/102472591
版权

一、引出

链式线性表，在内存中随机存储；底层实现层无法随机访问内部元素。底层不需要关心应用层的业务逻辑的长什么样的；只需要将一系列的元素给串接起来即可。C模版库不是C++类模版，它无法实现应用层和底层实现层的数据脱离关系，实例没办法复用；而且关联。

应用业务逻辑与底层实现层地址关联。即，只能对其中的实例实现局部赋值，清空操作。

二、思想

传统链表：

实现层与应用层关联，链表中包含数据域与指针域；无法将数据结构与具体的应用层业务逻辑分离；增删改查，释放集于一体。

数据是死的无法可长可短可宽可瘦，无法将接口给于他人使用。

Linux内核链表：

与传统链表不同的是，传统链表需要自己去包容世界；而Linux内核链表的高超思想是如何让大千世界来包容我。数据域加上固定的偏移量到达指针域，并将应用层业务结点中的指针域与底层实现层的指针链接进行地址重叠；内部组织数据结构，并负责数据的释放。

三、实现

借助于Linux内核链表的思想，将应用层头部置为指针域，去除数据偏移；并和底层实现层提供的接口层进行靠拢；将双方地址重叠；

即，底层不需要关心具体的业务逻辑，它要做的就是，用一根根的线把结点串接起来。为上层应用层提供所期望的数据逻辑结构。而具体的应用层无法通过底层提供的相应的接口改变其数据，所有的数据都需要应用层自己释放，自己操作与维护。更高级的操作交给其它数据操作接口去。

【底层实现层link.h】

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

//链表的基类型：
//仅包含一个需要被业务层重叠地址的next成员
typedef struct node{
	/*const*/ struct node *next;//底层要为上层提供服务无需置为只读
}LinkListnode;

/**********构造一个"类"结构体作为链表的基类型**********/
typedef struct{
	LinkListnode head;//链表的首元结点
	int length;//链表的长度(结点的个数)
	//int size;//链表的数据域大小
}LinkList;

/******************对链表进行初始化*******************/
/***************为了不值传二级指针********************
返回值：初始化后的链表首地址,和业务应用层的首地址
是重合的,业务应用层的数据底层不需要管,但是为了约定俗成
应用层的数据起始地址必须是LinkListnode类型
*****************************************************/
LinkList *init_link(void);

/***********对链表清空操作,但保留基类型********/
int clear_list(LinkList *list);

/*******对链表删除,删除数据与结构********/
int delete_list(LinkList *list);

/***********判断链式线性表是否为空?*************
条件:
1. 首元结点不存在,为错误处理 
2.首元结点的next值为NULL,判定为空
返回值：空1,非空0
***************************************/
int isEmpty(LinkList *list);

#if _COMMENT_
链式存储不存在满的情况
不支持随机访问,每次寻找数据必须找到
相应的地址,其时间复杂度同顺序存储相比,不容忽略
#endif

/******************链式线性表的指定插值*****************
规则:按位置进行插值,遍历到指定位置, 并在前一位置停止
统一以pos位置为基准,向后插入一个元素
********************************************************/
int insert_node(LinkList *list, LinkListnode *node, int pos);

/********************链式线性表的查找**************************
每次查找都是一次遍历,不可预估的时间复杂度(暂且忽略,完全轻松跑得起来)
*********************************************************/
LinkListnode *find_node(LinkList *list, int pos);

/******获取链式线性表的有效元素个数*******/
int get_length(LinkList *list);

/********************************************
删除链式线性表指定位置结点
返回值：成功返回1, 失败或错误找不到结点返回0
********************************************/
int delete_node(LinkList *list, int pos);


/*修改指定位置结点的值*/
int set_node(LinkList *list, LinkListnode *node, int pos);

#endif

【link.c】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "link.h"

LinkList *init_link(void)
{//创建链表基类型
    LinkList *obj = (LinkList *)malloc(sizeof(LinkList));
    //obj->head = (LinkListnode *)malloc(sizeof(LinkListnode));
    memset(obj, 0, sizeof(LinkList));
    //memset(obj->head, 0, sizeof(*(obj->head)));

    obj->head.next = NULL;
    obj->length = 0;
    if (obj != NULL)
    {
	return obj;
    }
    return NULL;
}

/*************************************************
业务层的起始地址是必须和底层匹配的
*************************************************/
int clear_list(LinkList *list)
{
    LinkListnode *p = NULL;
    int i = 0;

    if (NULL == list)
    {
        fprintf(stderr, "fatal_error");
	abort();
    }
    if (isEmpty(list))
    {
	printf("该链表为空链表");
	return 1;
    }
    p = &list->head;

#if 0
因为底层要不关心业务层的具体实现，所以数据域已经和指针域脱离了关系
直接解除这种数据结构的关系即可, 清空与数据无关, 直接首元结点指向NULL
告诉应用层现在你已经不具备数据结构了; 所占用的空间，你自己去释放吧
    for (i = 0; i < get_length(list); i++)
    {
	p = p->next;
	q = p;
	list->head->next = p->next;
	free(q);
	printf("%d ", get_length(list));
	list->length--;
    }
#endif
    p->next = NULL;
    list->length = 0;

    if (list->length == 0){//长度为0
	return 1;
    }
    else{
	return 0;
    }
}

//删除整个链表,释放链表
int delete_list(LinkList *list)
{
    if (NULL == list){
	fprintf(stderr, "fatal_error");
	abort();
    }
    if (clear_list(list)){
	//free(list->head);
	//list->head = NULL;
	free(list);
	list = NULL;
    }
    if (NULL == list){
	return 1;
    }
    else{
	return 0;
    }
}

//判断链表是否为空
int isEmpty(LinkList *list)
{
    if (NULL == list){
	fprintf(stderr, "fatal_error");
	abort();
    }
    if (list->head.next == NULL){
	return 1;
    }
    return 0;
}

//获取链表的长度
int get_length(LinkList *list)
{
    if (NULL == list){
	fprintf(stderr, "fatal_error");
	abort();
    }
    if (list->length >= 0){
	return list->length;
    }
    else{
	return -1;
    }
}

/************插入结点至顺序表中************/
int insert_node(LinkList *list, LinkListnode *node, int pos)
{
    int i = 0;
    LinkListnode *p = NULL;
    int len = 0;

    if (NULL == list || NULL == node || pos < 0)
    {
	fprintf(stderr, "fatal error!");
	abort();
    }
    len = get_length(list);//获取之前状态的长度

    if (isEmpty(list))//插到首元结点的后面
    {
	node->next = list->head.next;
	list->head.next = node;
	list->length++;
    }
    else//常规插入，到达指定位置后以指定pos为基准执行后插操作
    {
	p = &list->head;
//上面走过等于0的那一步了，后面就不需要再走一便pos = 0了,否则的将导致头结点始终是第一个插入链表的元素
	for (i = 0; i < pos; i++)
	{//大于等于长度会跳出循环,防止发生段错误
		if (i >= get_length(list)) break;
		p = p->next;
	}
	node->next = p->next;
	p->next = node;
	list->length++;

    }

    if (len != get_length(list))
	return 1;
    else
	return 0;
}

//断开指定结点位置的链接(应用层失去该节点的数据结构，变成独立的数据,在堆区仍需要手动释放)
int delete_node(LinkList *list, int pos)
{
    int i = 0, len = 0;;
    LinkListnode *p = NULL, *q = NULL;

    if (NULL == list || pos < 0)
    {
	fprintf(stderr, "fatal error");
	abort();
    }
    len = get_length(list);
    p = &list->head; q = &list->head;
    for (i = 0; i <= pos; i++)
    {
	if (i >= get_length(list)) break;
	q = p;
	p = p->next;
    }
    q->next = p->next;
    list->length--;
    if (len != get_length(list))
	return 1;
    else
	return 0;
}

int set_node(LinkList *list, LinkListnode *node, int pos)
{
    LinkListnode *p = NULL;
    int i = 0;
    if (NULL == list || NULL == node || pos < 0)
    {
	fprintf(stderr, "fatal error!");
	abort();
    }
    else
    {
	p = &list->head;
	for (i = 0; i <= pos; i++)
	{
	    if (i >= get_length(list)) break;
	    p = p->next;
	}
	p = node;//直接替换

	if (p == node)
	{
	    return 1;
	}
    }
    return 0;
}

//查找元素
LinkListnode *find_node(LinkList *list, int pos)
{
    LinkListnode *p = NULL;
    int i = 0;
    if (NULL == list || pos < 0)
    {
	fprintf(stderr, "fatal error");
	abort();
    }
    p = &list->head;
	
    for (i = 0; i <= pos; i++)
    {
	if (i >= get_length(list)) break;
	p = p->next;
    }

    if (p != &list->head)//找到了
	return p;
    else
	return NULL;

	return NULL;
}

【引用层的业务逻辑实现：main.c】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN_OS
#include <windows.h>
#endif
#include "seqlinklist.h"

#define _WIN_OS_

//应用层随意设计自己的数据类型
//但必须在头部包含一个双方约定好的指针域
typedef struct{
    const LinkListnode area;//设置为只读,应用层无法直接修改它
    int age;
    char name[20];
}Msg;

int main()
{
    LinkList *list = NULL; int i = 0;
    Msg *obj1, *obj2, *obj3, *obj4, *obj5;//堆区创建5个结点
    Msg *display = NULL;

    obj1 = (Msg *)malloc(sizeof(Msg)); memset(obj1, 0, sizeof(Msg));
    obj2 = (Msg *)malloc(sizeof(Msg)); memset(obj2, 0, sizeof(Msg));
    obj3 = (Msg *)malloc(sizeof(Msg)); memset(obj3, 0, sizeof(Msg));
    obj4 = (Msg *)malloc(sizeof(Msg)); memset(obj4, 0, sizeof(Msg));
    obj5 = (Msg *)malloc(sizeof(Msg)); memset(obj5, 0, sizeof(Msg));
	
    obj1->age = 10; strcpy(obj1->name, "小王");
    obj2->age = 11; strcpy(obj2->name, "小李");
    obj3->age = 12; strcpy(obj3->name, "小张");
    obj4->age = 13; strcpy(obj4->name, "小林");
    obj5->age = 14; strcpy(obj5->name, "小夏");

    list = init_link();
    if (list == NULL)
    {
        printf("初始化链表失败\n");
	free(obj1); free(obj2); free(obj3);
	free(obj4); free(obj5);
	exit(-1);
    }

    if (insert_node(list, (LinkListnode *)obj1, 0)  printf("插入obj1成功\n");
    if (insert_node(list, (LinkListnode *)obj2, 0)) printf("插入obj2成功\n");
    if (insert_node(list, (LinkListnode *)obj3, 0)) printf("插入obj3成功\n");
    if (insert_node(list, (LinkListnode *)obj4, 0)) printf("插入obj4成功\n");
    if (insert_node(list, (LinkListnode *)obj5, 0)) printf("插入obj5成功\n");
	
    printf("\n=================遍历链表=================\n");
    for (i = 0; i < get_length(list); i++)
    {
	display = (Msg *)find_node(list, i);
	printf("%s的年龄是%d\n", display->name, display->age);
    }

    printf("\n==========设置指定位置元素的数据结构，3号位置(4号值)==========\n");

//memset(obj2, 0, sizeof(Msg));这里注意：是不可修改应用层内存的!!!
//因为地址和底层实现层的地址是重叠的，一方修改了会相当于链表失去了其中一个元素的后继

    obj2->age = 23;
    strcpy(obj2->name, "halo");
    if (set_node(list, (LinkListnode *)obj2, 3))
    {
	printf("设置位置值成功\n");
	printf("=================遍历=================\n");
	for (i = 0; i < get_length(list); i++)
	{
	    display = (Msg *)find_node(list, i);
	    printf("%s的年龄是%d\n", display->name, display->age);
	}
    }
    else
    {
	printf("设置位置值失败\n");
    }

    printf("\n=======解除数据指定位置元素的数据结构，3号位置============\n");//应用层内存仍然存在
    if (delete_node(list, 3))
    {
        for (i = 0; i < get_length(list); i++)
        {
	    display = (Msg *)find_node(list, i);
	    printf("%s的年龄是%d\n", display->name, display->age);
        }
    }
    printf("\n=======解除所有元素的数据结构============\n");
    if (delete_list(list))
    {
        printf("解除成功,释放成功\n");
    }
    else
    {
	printf("解除失败\n");
    }

    free(obj1); free(obj2); free(obj3);
    free(obj4); free(obj5);

#ifdef _WIN_OS
	system("pause");
#endif

    return 0;
}

【Makefile】

.PHONY: all clean clean_a
obj = link.o main.o
target = test

cc = gcc
CFLAGS = -g -Wall

all:$(target)
$(target):$(obj)
	$(cc) $(obj) -o $@
list.o:link.c link.h
	$(cc) $(CFLAGS)  -c $^
main.o:main.c
	$(cc) $(CFLAGS)  -c $^

clean:
	rm -rf $(obj)
clean_a:
	rm -rf $(obj) $(target)

四、编译--->运行--->调试

五、总结

发现模版库写到最后就是像在写C++模版类，但实际在应用层上面复用完全没问题。只是相比较C++类模版来实现库会更加灵活，高效，方便。

继续重新学习认识编程语言与底层实现的美学。

 

-浓烟下的诗歌电台
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言模块化编程的完美解耦 - cevent应用
Letter
12-20 3500
前言 对于模块化编程来说，如何实现各模块间的解耦一直是一个比较令人头疼的问题，特别是对于嵌入式编程，由于控制逻辑复杂，并且对程序体积有控制，经常容易写出各独立模块之间相互调用的问题。由此，cpost中的cevent组件，通过模仿Android系统中的广播机制，提供了一种非常简单的模块间解耦实现 原理 cevent借鉴的是Android系统的广播机制，一方面，各模块在工作的时候，都会有多个具体的事件点，在高耦合的编程中，可能会在这些地方调用其他模块的功能，比如说，在通信模块接收到指令的时候，需要闪烁一下指示灯
嵌入式程序上下文切换和解耦的工具
strongerHuang
05-06 765
关注+星标公众号，不错过精彩内容作者 |NevermindZZTC语言是一种面向过程的语言，做嵌入式项目的时候，如果不变相面向对象，项目到后期很难做好，且不容易维护。今天就给大家推荐一个用于C语言程序上下文切换和解耦的工具。源码地址：https://github.com/NevermindZZT/cpost源码不多，主要就4个文件：具体源码就不一一描述了，大家可以直接下载，这里给大家介绍并描述下...
一文解决用C语言实现一个链表（全都是细节）
胡坚涛的博客
01-06 1705
链表是指数据使用一个一个的结点连接起来的数据结构，这样的数据结构中不像顺序表一样，顺序表中不同的数据在内存中的存储空间是相邻的，链表中的相邻结点在内存中的存储位置是没有任何关系的，每一个链表都是由许多的结点组成的，而一个链表，我们需要一个对应的头指针来管理这个链表，也就是说，如果我们拥有一个链表的头指针，那么我们就可以拿到这个链表中的所有的结点，在此基础上，如果我们还学会对链表中的结点进行一些常见的操作（增删查改），那么我们就可以熟练使用链表来解决现实中的问题了
C语言数据结构之双链表---链表&数据分离（从零写一个双链）
假如技术娶了生活...
08-01 507
双链程序
基于qt和ffmpeg视频播放器开发实战
11-09
ffmpeg是世界上应用广的开源视频处理框架，在各个平台（windows，linux，嵌入式、Android、IOS）被广泛应用，可以说是做视频相关项目技能qt是目前跨平台项目界面开发的第一选择，本课程基于这两种框架在加上VC++，给大家讲解延时如何开发出一个视频播放器，各个模块如何结合，如何考虑性能问题，如何设计封装类，如何处理各种异常情况。
链式线性表实现
07-28
链式线性表是一种数据结构，它在计算机科学中被广泛使用，特别是在处理大量有序或无序数据时。与顺序数组不同，链式线性表的元素不是在内存中的连续位置存储，而是通过链接节点来表示元素之间的关系。每个节点包含...
链表的C++实现（线性表的链式存储C++实现）
04-05
大致实现了STL中的链表的基本功能，通过对比C语言实现线性表的链式存储可以更好的理解面向对象编程和面向过程的区别，更加深入的理解C语言和C++语言的区别。相关的文章可以在我的主页算法与数据结构专栏查看。
线性表的顺序存储C++实现（类模板实现）
04-05
大致实现了STL中的线性表基本功能，通过对比C语言实现线性表的顺序存储可以更好的理解面向对象编程和面向过程的区别，更加深入的理解C语言和C++语言的区别。相关的文章可以在我的主页算法与数据结构专栏查看。
线性表的链式存储结构c++模板类实现
06-20
哈工大软设设计与开发实践1的课程要求代码，个人写的很粗糙简陋，仅供参考
EDEM离散元软件流场单向耦合api编程模版.rar
03-19
API编程模版通常包含了一些基本的代码框架和示例，帮助用户理解和实现特定的计算任务。在这个“EDEM离散元软件流场单向耦合API编程模版”中，我们可以预见到一些关键知识点： 1. **API接口理解**：学习和掌握EDEM ...
C 底层抽象层与应用层之间的解耦合测练(以顺序线性表为例)
浓烟下的诗歌电台
10-08 401
这是很重要的作为初级程序员应知应会的知识；我们要理解平时别人造的轮子，为什么给我用用的这么顺畅 STL模版库中的内部实现是怎么样的，c带给我们的一系列的接口(面向接口的编程)，C++模版库(多态，动态联编的能力)这一切值得我们去学习。
什么是耦合？解耦合的方法有哪几种？
忽如一夜听春雨的博客
09-03 4万+
在项目的开发过程中，我们经常强调项目的代码模块尽量做到低耦合高内聚，但是什么是耦合？怎样做到低耦合？可能有很多人感到疑惑，下面我来跟大家讲解什么是耦合，怎么进行解耦合实现低耦合。一、什么是耦合？ 耦合指的就是两个类之间的联系的紧密程度，看下面这段代码： public class A{ public int i; } public class B{
C++解耦合的一种方法
weixin_34242658的博客
09-05 860
以数据为中心，多模块之间使用全局变量来做消息通知，或者状态改变，这样模块之间没有直接的联系。各个模块都是直接使用全局变量而已。全局变量的问题这里不探讨。以我的实例讲解，游戏中的英雄（主角）在地图上自动奔跑到鼠标点击的地方，或者网络信令传过来的坐标位置上。主角的自动移动方法setAutoMovePos这里不细说原来的做法如下代码//Map.cpp文件 //鼠标按下事件 ...
C语言使用注册回调方式实现模块间交互（解耦合）
cchangcs
01-02 1082
C语言采用注册回调的方式进行模块间交互，实现模块间解耦合。
C语言数据结构之链表详细解析
Feeryman_Lee的博客
08-29 1082
单链表的头插法尾插法建立单链表，单链表的查找、插入、删除。 双链表的插入、删除、查找。
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
解耦合
fangqiangqi的博客
04-05 1万+
广大程序猿同胞，经常会看到“解耦合”，也有很多人，会用这个词来装X，但是，实际真正能理解的人，并不多。接下来，带大家深入浅出的走一遍，如何解耦合。首先，我们要知道，为什么要解耦合：通常，我们做一个项目，会用到很多基础功能块，比如xxx通信协议，xxxView等等，我们会把这种功能块封装成一个库，如果这个库，只能在这个指定的项目运行，这就叫高耦合，这就导致了，如果下次再次遇到一个类似的项目，需要用到...
c函数解耦原则
Forver的博客
12-17 6061
想要编写耦合性较低的代码，做时刻记住两个原则。 1、隔离变化 （1）代码功能中，不变的部分写进一个函数，变化的部分根据需求编写不同的函数； （2）执行时，只需把变化的函数做成参数传递给不变的函数里面，进行调用。这里主要用到函数指针来调用函数。 2、降低复杂度 （1）函数应该尽量精简，仅完成相对独立的简单功能； （2）函数的实现不应该太长，函数实现太长，应该反思能够如何修改(或拆分)使得函数更为精简、易懂。 ...
空间DID全部内容（Spatial DID）.txt
最新发布
07-11
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。样例数据及详细介绍参见文章：https://blog.csdn.net/li514006030/article/details/140362616
数据结构与算法（C语言）线性表（顺序存储、链式存储） 定义线性表节点的结构.pdf
04-18
数据结构与算法（C语言）线性表（顺序存储、链式存储） 定义线性表节点的结构.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值