C实现 list.c，尽量靠近STL::LIST

已于 2022-09-23 18:29:46 修改
阅读量118 收藏
点赞数
分类专栏： 编程语言 文章标签： c++ c语言 list
于 2022-09-21 20:06:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suxingtian/article/details/126979773
版权

自用记录：

list.h

#ifndef __LIST_H__
#define __LIST_H__

#include "stdint.h"
#include <stdlib.h>
#include <string.h>

typedef struct _list
{
	struct _list *next;
	struct _list *prev;
	void *data;
}list;


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

list *creat_list();

void delete_list(list *l);

int list_push_back(list *l,void *data,uint32_t data_size);
list * list_pop_back(list *l);

int list_push_front(list *l,void *data,uint32_t data_size);
list * list_pop_front(list *l);

/*
	date_compare(void*,void*) return 0 means find ok!
	return ok!=0,means find the 'data'!,user can not free the "ok"
*/
list* list_find(list *l,void *data,date_compare func);

list* list_remove(list *l,void *data,date_compare func);

list*  list_head(list *l);
list*  list_tail(list *l);

#endif

list.c 

#include "list.h"
#include <stdio.h>

#define MEM_CHECK	1
int g_mem_cnt=0;

void my_free(void *p)
{
	free(p);
	#if MEM_CHECK
	g_mem_cnt--;
	printf("g_mem_cnt=%d\n",g_mem_cnt);
	#endif
}

void* my_zalloc(uint32_t size)
{
	void *p = malloc(size);
	if(p!=NULL)
	{
		memset(p,0,size);
		#if MEM_CHECK
		g_mem_cnt++;
		printf("g_mem_cnt=%d\n",g_mem_cnt);
		#endif
	}
	return p;
}

list *creat_list()
{
	list *p;
	p = (list*)my_zalloc(sizeof(list));
	if(p!= NULL)
	{
		p->prev=NULL;
		p->next=NULL;
		p->data=NULL;
	}
	return p;
}

/*
	*l 可以 list中的任意一项，下同
*/
void delete_list(list *l)
{
	list *tmp=NULL;
	if(l==NULL)
	{
		return ;
	}
	
	list *head=l;
	while(head->prev!=NULL)
	{
		head = head->prev;
	}
	int i=0;
	while(head!=NULL)
	{		
		if(head->data)my_free(head->data);
		
		if(head->next== NULL)
		{
			my_free(head);
			break;
		}
		else
		{
			head = head->next;
			my_free(head->prev);
			head->prev = 0;
		}
	}
}

int list_push_back(list *l,void *data,uint32_t data_size)
{
	if(l==NULL || data==NULL)
	{
		return -1;
	}
	
	if(l->next==NULL && l->prev==NULL && l->data==NULL)
	{
		l->data = my_zalloc(data_size);
		if(l->data==NULL)
		{
			return -1;
		}
		memcpy(l->data,data,data_size);
		return 0;
	}
	
	list *p=(list*)my_zalloc(sizeof(list));
	if(p == NULL)
	{
		return -1;
	}
	memset(p,0,sizeof(list));
	
	p->data = my_zalloc(data_size);
	if(p->data==NULL)
	{
		my_free(p);
		return -1;
	}
	memcpy(p->data,data,data_size);
		
	list *tail=l;
	while(tail->next!=NULL)
	{
		tail = tail->next;
	}
	
	tail->next = p;
	p->prev = tail;
	
	return 0;
}

list *list_pop_back(list *l)
{
	if(l==NULL)
	{
		return NULL;
	}
	
	list *tail=l;
	while(tail->next!=NULL)
	{
		tail = tail->next;
	}
	
	if(tail->prev==NULL)//only 1 elemt
	{
		if(tail->data)my_free(tail->data);
		my_free(tail);
		tail = NULL;
	}
	else
	{
		tail = tail->prev;
		if(tail->data)my_free(tail->next->data);
		my_free(tail->next);
		tail->next = NULL;
	}
	
	return tail;
}

int list_push_front(list *l,void *data,uint32_t data_size)
{
	if(l==NULL || data==NULL)
	{
		return -1;
	}

	if(l->next==NULL && l->prev==NULL && l->data==NULL)
	{
		l->data = my_zalloc(data_size);
		if(l->data==NULL)
		{
			return -1;
		}
		memcpy(l->data,data,data_size);
		return 0;
	}
	
	list *p=(list*)my_zalloc(sizeof(list));
	if(p == NULL)
	{
		return -1;
	}
	
	p->data = my_zalloc(data_size);
	if(p->data==NULL)
	{
		my_free(p);
		return -1;
	}
	memcpy(p->data,data,data_size);
	
	list *head=l;	
	while(head->prev!=NULL)
	{
		head = head->prev;
	}
	
	head->prev = p;
	p->next = head;
	
	return 0;
}


list *  list_pop_front(list *l)
{
	if(l==NULL)
	{
		return NULL;
	}
	
	list *head=l;	
	while(head->prev!=NULL)
	{
		head = head->prev;
	}
	
	if(head->next==NULL)//only 1 elemt
	{
		if(head->data)my_free(head->data);
		my_free(head);
		head = NULL;
	}
	else
	{
		head = head->next;
		if(head->data)my_free(head->prev->data);
		my_free(head->prev);
		head->prev = NULL;
	}
	return head;
}

/*
	date_compare(void *a,void *b); a == b return 0 ; a > b return 1 ;a < b return
	return 0:no found!
	NOTE:user can not free the "ok"
*/
list* list_find(list *l,void *data,date_compare func)
{
	list *ok=NULL;
	if(l==NULL || data==NULL)
	{
		return ok;
	}
	
	list *find=l;
	
	while(find!=NULL)
	{
		if(0==func(find->data,data))
		{
			ok = find;
			break;
		}
	}	
	return ok;
}

static list* list_del(list *l)
{
	list *ret = NULL;
	if(l==NULL)
	{
		return NULL;
	}
	

	if(l->next == NULL)
	{
		if(l->prev == NULL)
		{
			free(l->data);
			free(l);
			return NULL;
		}
		else
		{
			free(l->data);

			l = l->prev;
			l->next = NULL;
			ret = l;
		}
	}
	else
	{
		if(l->prev == NULL)
		{
			free(l->data);

			l = l->next;
			l->prev = NULL;
			ret = l;
		}
		else
		{
			free(l->data);

			l->next->prev = l->prev;
			l->prev->next = l->next;
			ret = l->prev;
			free(l);
		}
	}
	return ret;
}

list* list_remove(list *l,void *data,date_compare func)
{
	list *e = list_find(l,data,func);
	if(e==NULL)//没找到
		return l;

	return list_del(e);
}

list*  list_head(list *l)
{
	list *head=NULL;
	if(l==NULL)
	{
		return head;
	}
	
	head=l;	
	while(head->prev!=NULL)
	{
		head = head->prev;
	}	
	
	return head;
}

list*  list_tail(list *l)
{
	list *tail=NULL;
	if(l==NULL)
	{
		return tail;
	}
	
	tail=l;	
	while(tail->next!=NULL)
	{
		tail = tail->next;
	}	
	return tail;
}

main.c 包含了检查进程以及线程的状态信息

#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <netdb.h>
#include <setjmp.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <memory.h>

#include "list.h"


char* safe_strncpy(char *dst, const char *src, size_t size)
{
	if (!size) return dst;
	dst[--size] = '\0';
	return strncpy(dst, src, size);
}

enum { COMM_LEN = 16 };
#define CMD_SIZE 64
typedef struct {
	DIR *dir;
	uint8_t shift_pages_to_bytes;
	uint8_t shift_pages_to_kb;
/* Fields are set to 0/NULL if failed to determine (or not requested) */
	uint16_t argv_len;
	/* Everything below must contain no ptrs to malloc'ed data:
	 * it is memset(0) for each process in procps_scan() */
	unsigned long vsz, rss; /* we round it to kbytes */
	unsigned long stime, utime;
	unsigned long start_time;
	unsigned pid;
	unsigned ppid;
	unsigned pgid;
	unsigned sid;
	unsigned uid;
	unsigned gid;

	unsigned tty_major,tty_minor;

	char state[4];
	char comm[COMM_LEN];
	char argv0[CMD_SIZE];
} procps_status_t;


#define PROCPS_BUFSIZE 1024

static int read_to_buf(const char *filename, void *buf)
{
	int fd;
	ssize_t ret = -1;
	fd = open(filename, O_RDONLY);
	if (fd >= 0) {
		ret = read(fd, buf, PROCPS_BUFSIZE-1);
		close(fd);
	}
	((char *)buf)[ret > 0 ? ret : 0] = '\0';
	return ret;
}

typedef struct          //定义一个cpu occupy的结构体
{
    char name[20];                  //定义一个char类型的数组名name有20个元素
    unsigned int user;              //定义一个无符号的int类型的user
    unsigned int nice;              //定义一个无符号的int类型的nice
    unsigned int system;            //定义一个无符号的int类型的system
    unsigned int idle;              //定义一个无符号的int类型的idle
    unsigned int iowait;
    unsigned int irq;
    unsigned int softirq;
}cpu_occupy_t;

int get_CPU(cpu_occupy_t *cpu)
{
	int n=0;
    char buf[PROCPS_BUFSIZE];
	char *filename="/proc/stat";
	n = read_to_buf(filename, buf);
	if(n<0)
	{
		printf("err_line=%d,filename=%s\n",__LINE__,filename);
		return -1;
	}
 
    n = sscanf (buf, "%s %u %u %u %u %u %u %u", cpu->name, &cpu->user, &cpu->nice,&cpu->system, &cpu->idle ,&cpu->iowait,&cpu->irq,&cpu->softirq);
	if(n < 8)
	{
		printf("err_lin=%d,filename=%s\n",__LINE__,filename);
		return -1;
	}
	
	printf("user=%u nice=%d system=%d idle=%d\n",cpu->user,cpu->nice,cpu->system,cpu->idle);
	return 0;
}

/*
打印进程内存情况和CPU情况, 以及每个子线程(如果存在)
*/

int  get_threadCPU(procps_status_t* sp,char *filename,char *filename_tail,char flag)
{	
	int n=0;
	char *cp, *comm1;
	int tty;
	unsigned long vsz, rss;
	long tasknice;
	char buf[PROCPS_BUFSIZE];
	
	strcpy(filename_tail, "stat");
	//printf("filename_tail=%s\n",filename);
	n = read_to_buf(filename, buf);
	if(n<0)
	{
		printf("err_lin=%d,filename=%s\n",__LINE__,filename);
		return -1;
	}
	cp = strchr(buf,')');
	cp[0] = '\0';
	
	comm1 = strchr(buf,'(');
	
	safe_strncpy(sp->comm, comm1 + 1, sizeof(sp->comm));
	//printf("cp=%s\n",cp+2);
	n = sscanf(cp+2,
		"%c %u "               /* state, ppid */
		"%u %u %d %*s "        /* pgid, sid, tty, tpgid */
		"%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
		"%lu %lu "             /* utime, stime */
		"%*s %*s %*s "         /* cutime, cstime, priority */
		"%ld "                 /* nice */
		"%*s %*s "             /* timeout, it_real_value */
		"%lu "                 /* start_time */
		"%lu "                 /* vsize */
		"%lu "                 /* rss */
		,
		sp->state, &sp->ppid,
		&sp->pgid, &sp->sid, &tty,
		&sp->utime, &sp->stime,
		&tasknice,
		&sp->start_time,
		&vsz,
		&rss);
	if(n < 11)
	{
		printf("err_lin=%d,filename=%s\n",__LINE__,filename);
		return -1;
	}
	
	sp->vsz = vsz >> 10;
	sp->rss = rss << sp->shift_pages_to_kb;
	sp->tty_major = (tty >> 8) & 0xfff;
	sp->tty_minor = (tty & 0xff) | ((tty >> 12) & 0xfff00);	
	
	if(flag & 0x01)
	{
		strcpy(filename_tail, "cmdline");
		n = read_to_buf(filename, buf);
		if(n<0)
		{
			printf("err_lin=%d,filename=%s\n",__LINE__,filename);
			return -1;
		}
		safe_strncpy(sp->argv0,buf,n>CMD_SIZE ? CMD_SIZE : n);
	}
	return 0;
}

int get_processCPU(uint32_t pid,list *my_list)
{
	char filename[sizeof("/proc/%u/task/%u/cmdline") + sizeof(int)*3 * 2];
	char *filename_tail=0;

	struct dirent *entry;
	procps_status_t sp;
	cpu_occupy_t cpu;
	
	unsigned p_size = getpagesize();
	while (1) {
		p_size >>= 1;
		if (!p_size) break;
		sp.shift_pages_to_bytes++;
	}
	sp.shift_pages_to_kb = sp.shift_pages_to_bytes - 10;
	
	//all cpu
	//get_CPU(&cpu);
	
	//all process
	filename_tail = filename + sprintf(filename, "/proc/%u/", pid);;
	if(get_threadCPU(&sp,filename,filename_tail,1)==0)
	{
		sp.pid = pid;			
		//printf("[%s]state=%C pid=%u utime=%lu stime=%lu vsz=%lu rss=%lu\n",
				//sp.argv0,sp.state[0],sp.pid,sp.utime,sp.stime,sp.vsz,sp.rss);	
		list_push_front(my_list,&sp,sizeof(sp));				
	}
	else
	{
		printf("err_lin=%d,get_threadCPU err\n",__LINE__);
		return -1;
	}


	//thread info
	sprintf(filename, "/proc/%u/task", pid);
	DIR *dir=opendir(filename);
	if(dir==NULL)
	{
		printf("err_lin=%d,filename=%s\n",__LINE__,filename);
		return -1;
	}
	
	for(;;)
	{
		entry = readdir(dir);
		if(entry==NULL)
			break;
		
		if( (0==strcmp(entry->d_name,".")) || (0==strcmp(entry->d_name,".."))  )
		{
		    continue;
		}
		
		if(entry->d_type == DT_DIR )
		{
			sp.pid = atoi(entry->d_name);
			if(sp.pid == pid)
				continue;
			filename_tail = filename + sprintf(filename, "/proc/%u/task/%s/", pid,entry->d_name);
			if(get_threadCPU(&sp,filename,filename_tail,0)==0)
			{						
				//printf("\t[%s]state=%C pid=%-6u utime=%-6lu stime=%-6lu\n",
				//sp.comm,sp.state[0],sp.pid,sp.utime,sp.stime);	

				list_push_front(my_list,&sp,sizeof(sp));				
			}
		}
	}	
	closedir(dir);

	
}

/*
*/
void test01(uint32_t pid)
{
	list *my_list = creat_list();
	get_processCPU(pid,my_list);

	printf("pid=%d\n",pid);
	
	procps_status_t *sp;
	list *itr = list_head(my_list);
	for(;itr!=NULL;itr=itr->next)
	{
		sp = (procps_status_t*)itr->data;
		if(sp == NULL)
			continue;
		if(sp->pid == pid)
		{
			printf("[%s]state=%C pid=%u utime=%lu stime=%lu vsz=%lu rss=%lu\n",
				sp->argv0,sp->state[0],sp->pid,sp->utime,sp->stime,sp->vsz,sp->rss);
		}
		else
		{
			printf("\t[%s]state=%C pid=%-6u utime=%-6lu stime=%-6lu\n",
				sp->comm,sp->state[0],sp->pid,sp->utime,sp->stime);
		}
	}

	my_list=list_pop_back(my_list);

	my_list = list_pop_front(my_list);

	delete_list(my_list);
}

int main(int argc,char* argv[])
{
	
	uint32_t pid=0;

	if(argc>1)
	{
		pid = atoi(argv[1]);
	}

	uint32_t s_pid = getpid();

	if(pid==0)
		pid=s_pid;

	test01(pid);
}

suxingtian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 List（数组实现）C++
cccccchao的博客
06-02 1912
写在前面： 好久没有写博客了，趁着这个周末作业不算太多，好好总结一下这学期学过的的数据结构好了。 话说，，临近学期末了，我才明白，数据结构学下来，所得的成果应该是众多自己写的头文件，，，应该还不晚8，，QAQ 简介： 数组实现的List。 与双链表实现的相比，随机访问效率高，但插入和删除元素的效率低。 因为必须初始化一个大小，所以有溢出风险。 代码： const int max_list=50; ...
两种通用链表（Linux 内核链表）
qq_32742637的博客
10-20 1647
Linux 内核链表（通用版） 以下是头文件 #define _CRT_SECURE_NO_WARNINGS #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include #include #include #include typedef struct _Tag_LinkNode //用来保存下一个节点 { struct _Tag_
指针简介（3）—— 指针函数与函数指针
静祥阁
03-18 812
声明： 本文是阅读周立功老师的程序设计与数据结构后所写，很多内容其实是书中的内容，所以如果您想了解更多这方面的知识，您可以阅读这本书。 在前面一节我们简单介绍了指针、数组、指针数组以及数组指针。而在这一节中我们主要介绍两个概念：函数指针函数以及函数指针。 指针函数： 说到指针函数，他的主体还是一个函数，但是他的返回值为指针类型，因此我们...
学生成绩表c语言,学生成绩信息表(c语言程序)
weixin_36242131的博客
05-17 1330
《学生成绩信息表(c语言程序)》由会员分享，可在线阅读，更多相关《学生成绩信息表(c语言程序)(16页珍藏版)》请在人人文库网上搜索。1、 include# include# includetypedef struct studentint ij;char no10;char name10;float score2;float average;student;typedef struct link...
c++ list
sy2453的博客
04-19 1166
1.list介绍 2.list的构造 3.迭代器 4.容量相关 5.元素访问 6.修改 7.特殊操作 8. list的迭代器失效 9.list模拟实现
C++ STL: list使用及源码剖析
暮色年华的博客
02-15 1219
push_front()，push_back（），pop_front()， pop_back()在insert和erase的基础上实现。如果指针node指向置于尾端的一个空白节点，node就能符合stl对于前闭后开区间的要求，这样以下函数便能轻易完成。链表最后使用一个指针指向环形链表的空白节点，空白节点指向头节点，这样就形成了一个环了。可以看出list节点是一个双向链表，next指向下一个节点，prev指向前一个节点。node是指向list节点的一个指针，可以使用这个指针表示整个环状双向链表。
【C++】模拟实现STL容器：list
学了就忘是正常现象
12-06 1647
list的普通迭代器通过类进行封装+运算符重载实现。 list的const通过类模板实现。 operator*返回节点的数据。 operator->返回节点数据的指针。
STL：List从0到1
最新发布
2301_77509762的博客
03-16 2424
STL容器List的介绍以及模拟实现
[C++ STL] list::back()
K.Sun
12-23 1658
list::back()，输出容器中最后一个元素： #include<iostream> #include<list> int main(){ // Initialization of list std::list<int> _list; // Adding elements to the list _list.push_bac...
c_list.rar_STL c语言_c li_双链表
09-24
在这个压缩包"**c_list.rar_STL c语言_c li_双链表**"中，作者通过模拟C++的STL接口，为C语言实现了一个双链表的数据结构，让我们能够体验到类似STL的功能。 双链表是一种数据结构，每个节点包含两个指针，分别指向...
STL.rar_C++ STL_STL_site:www.pudn.com_visual c
09-23
STL的主要目标是提高代码的可读性、可维护性和性能，通过使用泛型编程实现。在本资料"STL.rar"中，我们重点探讨的是STL在C++中的应用，尤其是与Visual C++的结合使用。 STL的核心组成部分包括容器、迭代器、算法和...
STL.rar_STL_site:www.pudn.com
09-20
1. 容器：这是STL中用于存储数据的主要结构，包括vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（键值对映射）等。每个容器都有其特定的访问和操作方式，例如vector支持...
STL.zip_site:www.pudn.com
09-22
STL的主要目标是提高代码的可读性、可维护性和性能，通过使用泛型编程和模板机制实现。在本教程中，你将深入理解STL的核心组件，并通过示例程序来加深理解。 首先，STL包括四大核心部分： 1. 容器（Containers）：...
stl.rar_site:www.pudn.com
09-24
1. 容器：这是STL中最重要的部分，包括如vector、list、deque、set、map等不同类型的容器。vector是一个动态数组，可以方便地在任何位置插入或删除元素；list则由双向链表构成，适合频繁的插入和删除操作；deque...
LNMP环境搭建
suxingtian的博客
01-28 3681
LNMP环境搭建 linux centos7.9 腾讯云 FTP配置 yum install vsftpd useradd -d /usr/share/nginx/html/wordpress wordpress vim /etc/vsftpd/vsftpd.conf chroot_local_user=YES #所有用户限制在自己home目录 allow_writeable_chroot=YES 重启生效 systemctl restart vsftpd SFTP服务配置 创建用户 us
meson 工具使用 glib-2.68.1交叉编译
suxingtian的博客
04-12 3254
需要python meson ninja，安装方法百度即可 meson手册https://mesonbuild.com/Manual.html 防止忘记，仅仅记录如下 #!/bin/bash set -e DEVEL=/home/username/build_root/devel if [ -d _build ];then rm -r _build fi mkdir _build arch='arm-linux-gnueabi-' sys_root='/home/username/bui..
tcp-server-echo epull
suxingtian的博客
04-12 2550
直接上代码 #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <string.h> #include <sys/stat.h> #include <sys/ioctl.h> #include <sys/types.h> #include <sys/socket.h> #in
Opencv——动态二值化阈值
suxingtian的博客
04-14 1787
算了不写太多解释了,毕竟免费的文章，我这代码看得懂的人自然也写得出来。 /** * @brief ImageProcess::peakValley * @param img * @param n * @param p peak * @param v valley * @return */ int ImageProcess::peakValley(Mat img,int n,in...
mysql 基础操作
suxingtian的博客
01-28 1279
MariaDB安装配置 简介 MariaDB 是mysql的开源免费分支，命令兼容 环境 centos7.9 安装 启动 开机启动 yum install mariadb-server systemctl start mariadb systemctl enable mariadb 查看启动结果 ps -aux | grep mysqld /bin/sh /usr/bin/mysqld_safe --basedir=/usr /usr/libexec/mysqld --basedir=/usr --
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值