文件IO（三）

左移右移

Linux的man 手册

文件IO

打开文件

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
int creat(const char *pathname, mode_t mode);
第二个open是第一个open和creat的结合版：
函数功能：打开文件
函数参数1：被打开文件的路径
函数参数2：以什么样的形式打开文件
必须包含如下的其中一个
O_RDONLY : 以只读的形式打开该文件
如果其他用户想要拥有写的权限，可以使用 umask函数来改变用户的文件掩码
操作文件：
O_WRONLY : 以只写的形式打开该文件
O_RDWR : 以读写的形式打开该文件
如果需要别的权限，要使用 | 形式拼装 a O_WRONLY | O_CREAT | O_APPEND
O_EXCL：如果文件已经存在，则打开操作失败。通常与 O_CREAT 一起使用，用于确保创建新文件而不覆盖
已存在的文件。
O_CREAT：如果文件不存在，则创建文件。如果文件已存在，它不会被截断，而只是打开。
O_TRUNC：如果文件已经存在，将文件长度清为0。这将删除文件的现有内容。
O_APPEND：将文件指针设置到文件末尾，以便所有写入操作都追加到文件末尾，而不是覆盖现有内容。
O_NONBLOCK：以非阻塞模式打开文件。在非阻塞模式下，读取和写入操作将不会被阻塞，即使没有可用的数
据或空间。
O_NDELAY同O_NONBLOCK
O_SYNC：要求所有I/O操作是同步的，即写入操作完成后，才返回。这可以确保数据写入到磁盘而不是缓存在
内存中。
O_DIRECTORY：要求打开的是一个目录而不是文件。用于确保只能打开目录。
O_NOFOLLOW：如果 pathname 是一个符号链接，则打开操作失败。用于防止解引用符号链接。
O_DIRECT：要求绕过内核缓存，直接在应用程序和存储设备之间进行数据传输。通常用于低级I/O操作和性
能优化。
O_TMPFILE：创建一个临时文件，该文件在关闭后会自动删除。适用于需要临时文件的场景。
O_NOCTTY如果欲打开的文件为终端机设备时,则不会将该终端机当成进程控制终端机
函数参数3：创建文件的权限 权限用二进制表示
函数返回值：成功返回文件描述符，失败返回-1（有可能会设置errno）

如果其他用户想要拥有写的权限，可以使用 umask函数来改变用户的文件掩码

操作文件

read/write
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
函数功能：从fd表示的文件中读取count个数据给buf
函数返回值：成功返回成功读到的个数，，读完了返回0，失败返回-1并更新errno
ssize_t write(int fd, const void *buf, size_t count);
函数功能：从buf表示的空间往fd表示的文件中写入count个数据
函数返回值：成功返回成功写入的个数，0表示什么也没写，失败返回-1并更新errno

关闭文件

#include <unistd.h>
int close(int fd);
函数功能：关闭fd表示的文件
函数返回值：成功返回0，失败返回-1并更新errno

caps lock开灯关灯

开灯
sudo sh -c “echo 1 > /sys/class/leds/input1::capslock/brightness”
关灯
sudo sh -c “echo 0 > /sys/class/leds/input1::capslock/brightness”

读取按键

按键和鼠标由linux输入子系统控制，还可以管理手柄，触摸屏等设备
打开键盘的设备文件之后，如果按键被按下或者被抬起，内核会将键盘触发的事件发送给应用程序
应用程序可以使用read函数读取事件，事件的结构体：

struct input_event
{
struct timeval time; //事件发生的时间
unsigned short type; //事件的类型，按键被按下或被抬起 EV_KEY 鼠标移动 EV_REL
unsigned short code; //事件编码，按键的编码
unsigned int value; //按键事件中，0表示按键抬起，1表示按下，2表示连击
}

按键编码在 /usr/include/linux/input-event-codes.h 文件中定义，程序中可以包含这一个头文件

#include <linux/input-event-codes.h>

通过按键事件的code字段进行判断

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/input.h>
#include <stdio.h>
#include <linux/input-event-codes.h>
int main(int argc, const char *argv[])
{
int fd = 0;
//1.打开文件
if(0 > (fd = open("/dev/input/event1", O_RDONLY)))
{
	perror("open");
	return -1;
}
struct input_event ev;
//2.读文件
while(1)
{
	read(fd, &ev, sizeof(ev)); //read(1.fd, 2.buf, 3.size);
#if 0
	//检测按键是否被按下
	if(ev.type == EV_KEY )
	{
		switch(ev.value)
		{
			case 0:
				printf("taiqi\n");
				break;
			case 1:
				puts("anxia");
				break;
			case 2:
				puts("lianji");
				break;
		}
	}
#endif
#if 1
	//检测特定按键
	if(ev.type == EV_KEY && ev.code == KEY_LEFTCTRL)
	{
		switch(ev.value)
		{
			case 0:
				printf("ctrl taiqi\n");
				break;
			case 1:
				puts("ctrl anxia");
				break;
			case 2:
				puts("ctrl lianji");
				break;
		}
	}
#endif
}
//3.关闭文件
close(fd);
return 0;
}

文件IO操作目录文件

打开目录文件

opendir
#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);
函数功能：打开name所表示的目录文件
函数返回值：成功返回目录流指针，失败返回NULL并更新errno

操作目录文件

读
readdir
#include <dirent.h>
struct dirent *readdir(DIR dirp);
函数功能：读取dirp表示的文件的某一个成员
函数返回值：成功返回指向目录结构体的指针，失败或者读完了返回NULL
struct dirent {
ino_t d_ino; / Inode number /
off_t d_off; / Not an offset; see below /
unsigned short d_reclen; / Length of this record /
unsigned char d_type; / Type of file; not supported
by all filesystem types /
char d_name[256]; / Null-terminated filename */
};

案例：实现 ls -a -i 的命令

#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
//程序的调用语法 ./xxxx <name>
int main(int argc, const char *argv[])
{
	DIR *pdir = NULL; //避免野指针的出现
	struct dirent *psrt = NULL;
	//入参判断
	if(argc < 2)
	{
		puts("argv: <./xxxx> <name>");
		return -1;
	}
	//打开目录
	if(!(pdir = opendir(argv[1]))) //DIR *opendir(name);
	{ // = 赋值语句的值：是 = 右边的值
		perror("opendir");
		return -1;
	}
	//操作目录
	//循环读取目录的信息，读完了 NULL
	while(1)
	{
		if(!(psrt = readdir(pdir))) //readir的返回值是否为NULL
		{
			break;
		}
		//实现 ls -a -i
		//打印成员的 inode name
		printf("%ld %s\n", psrt->d_ino, psrt->d_name);
	}
	//关闭目录
	closedir(pdir);
	return 0;
}

实现：ls
案例：模拟实现 ls -l 的命令

获取文件详细信息：
stat
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *pathname, struct stat *statbuf);
int fstat(int fd, struct stat *statbuf);
int lstat(const char *pathname, struct stat statbuf);
stat和lstat没有任何区别，但是当pathname是一个链接文件的时候，lstat会返回链接本身的信息，而不是源
文件的信息
函数功能：获取pathname所表示的文件的详细信息，信息放入到statbuf所指示的空间（由我们去开辟的）
返回值：成功返回0，失败返回-1并更新errno
struct stat {
dev_t st_dev; / ID of device containing file /
ino_t st_ino; / Inode number /
mode_t st_mode; / File type and mode /
nlink_t st_nlink; / Number of hard links /
uid_t st_uid; / User ID of owner /
gid_t st_gid; / Group ID of owner /
dev_t st_rdev; / Device ID (if special file) /
off_t st_size; / Total size, in bytes /
blksize_t st_blksize; / Block size for filesystem I/O /
blkcnt_t st_blocks; / Number of 512B blocks allocated /
/ Since Linux 2.6, the kernel supports nanosecond
precision for the following timestamp fields.
For the details before Linux 2.6, see NOTES. /
struct timespec st_atim; / Time of last access /
struct timespec st_mtim; / Time of last modification /
struct timespec st_ctim; / Time of last status change /
#define st_atime st_atim.tv_sec / Backward compatibility */
#define st_mtime st_mtim.tv_sec
#define st_ctime st_ctim.tv_sec
};

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
//程序的调用语法 ./xxxx <name>
int main(int argc, const char *argv[])
{
	DIR *pdir = NULL; //避免野指针的出现
	struct dirent *psrt = NULL;
	struct tm *pt = NULL;
	//定义路径
	char pathname[300] = {0};
	struct stat *pst = (struct stat *)malloc(sizeof(struct stat));
	//入参判断
	if(argc < 2)
	{
		puts("argv: <./xxxx> <name>");
		return -1;
	}
	//打开目录
	if(!(pdir = opendir(argv[1]))) //DIR *opendir(name);
	{ // = 赋值语句的值：是 = 右边的值
		perror("opendir");
		return -1;
	}
	//操作目录
	//循环读取目录的信息，读完了 NULL
	while(1)
	{
		if(!(psrt = readdir(pdir))) //readir的返回值是否为NULL
		{
		break;
		}
		//实现 ls -l
		if(psrt->d_name[0] == '.') continue;
		//使用lstat函数获取详细的信息
		sprintf(pathname, "%s/%s", argv[1], psrt->d_name);
		memset(pst, 0, sizeof(struct stat));
		//%s/%s argv[1] psrt->d_name;
		if(lstat(pathname, pst)) //lstat(pathname, struct stat *statbuf);
		{
		perror("stat");
		goto ERR;
		}
		//文件的类型 - d p ...
		switch(pst->st_mode & S_IFMT)
		{
			case S_IFSOCK:
				printf("s");
				break;
			case S_IFREG:
				printf("-");
				break;
		}
		if(S_ISDIR(pst->st_mode))
		{
			printf("d");
		}
		//文件的权限 rwx
		for(int i=8; i>=0; i--)
		{
			if(pst->st_mode & 1<<i)
			{
				//判断是r w x
				switch(i % 3)
				{
					case 2:
						printf("r");
						break;
					case 1:
						printf("w");
						break;
					case 0:
						printf("x");
						break;
				}
			}
			else
			{
				printf("-");
			}
		}
		//文件链接数
		printf(" %ld ", pst->st_nlink);
		//文件所有者
		if(pst->st_uid == 1000)
		{
			printf("linux ");
		}
		//文件所属组
		if(pst->st_gid == 1000)
		{
			printf("linux ");
		}
		//文件大小
		printf("%ld\t", pst->st_size);
		//文件修改时间
		pt = localtime((const time_t *)&pst->st_mtim); //将时间戳转换成年月日
		printf("%2d 月 %2d %2d:%2d ", pt->tm_mon+1, pt->tm_mday,\
		pt->tm_hour, pt->tm_min);
		//文件名
		printf("%s\n", psrt->d_name);
	}
	ERR:free(pst);
	//关闭目录
	closedir(pdir);
	return 0;
}

库

本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。由于windows和linux的本质不同，因此二者库的二进制是不兼容的。
linux下的库有两种：静态库和共享库（动态库）。二者的不同点在于代码被载入的时刻不同。
静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，因此体积较大。
动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在，因此代码体积较小。

动态库和静态库的优缺点

静态库对函数库的链接是放在编译时期（compile time）完成的。
程序在运行时与函数库再无瓜葛，移植方便
浪费空间和资源，因为所有相关的对象文件（object file）与牵涉到的函数库（library）被链接合成一个可执行文件（executable file）。
—》编译时把静态库中的相关代码复制到可执行程序中
优点：程序运行时，无需加载库，运行速度更快，独立性高，移植性好
缺点：占用更多磁盘和内存空间，静态库升级后，需要重新编译链接

动态库把对一些库函数的链接载入推迟到程序运行的时期（runtime）。
可以实现进程之间的资源共享。
将一些程序升级变得简单。
甚至可以真正做到链接载入完全由程序员在程序代码中控制。
----》编译时仅记录用到哪个共享库中的哪个符号，不复制共享库中的相关代码
优点：程序不包含库中代码，体积比较小，库升级方便，无需重新编译
缺点：在运行需要加载共享库，浪费时间，独立性不好，移植性差

创建静态库

创建动态库

按下右ctrl键 亮灭灯

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>
#include <linux/input-event-codes.h>
//按下右ctrl健 亮灭灯
int main(int argc, const char *argv[])
{
	int fdkey = 0;
	int fdled = 0;
	//打开文件
	//int open(const char *pathname,int flags,mode_t mode)
	//成功返回文件描述符，失败返回-1
	fdkey = open("/dev/input/event1", O_RDONLY);
	fdled =
	open("/sys/class/leds/input1::capslock/brightness",O_WRONLY);
	if(fdkey == -1 || fdled == -1)
	{
		perror("open");
		return -1;
	}
	struct input_event ev;
	while(1)
	{
		//read(int fd,void *buf,size_t count)读文件
		read(fdkey,&ev, sizeof(ev));
		if(ev.type == EV_KEY && ev.code == KEY_RIGHTCTRL)
		{
			switch(ev.value)
			{
			case 0:
				printf("ctrl tq\n");
				write(fdled,"0",1);
				break;
			case 1:
				printf("ctrl ax\n");
				write(fdled,"1",1);
				break;
			case 2:
				printf("ctrl lj\n");
				break;
			}
		}
	}
	close(fdled);
	close(fdkey);
	return 0;
}