【嵌入式学习】IO进程线程-Day3-IO基础

最新推荐文章于 2024-07-22 17:32:31 发布
最新推荐文章于 2024-07-22 17:32:31 发布
阅读量397 收藏 8
点赞数
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56295733/article/details/135373432
版权

作业

  1. 使用标准io完成两个文件的拷贝
#include <stdio.h>

int main(int argc, const char *argv[]){
	if(argc!=3){
		puts("输入有误！");
		return -1;
	}
	FILE* fp=NULL;
	FILE*fp_cp=NULL;
	if((fp=fopen(argv[1],"r"))==NULL){
		perror("打开1文件出错：");
		return -1;
	}

	if((fp_cp=fopen(argv[2],"w"))==NULL){
		perror("打开2文件出错：");
		return -1;
	}

	char buff[1024];
	while(fgets(buff,sizeof(buff),fp)!=NULL){
		fputs(buff,fp_cp);
	}

	puts("拷贝成功！");
	fclose(fp);
	fclose(fp_cp);
	return 0;
}
  1. 使用文件IO完成两个文件的拷贝
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, const char *argv[])
{
    if(argc!=3)
    {
        puts("输入有误");
        return -1;
    }
    int fd=-1,fd_cp=-1;
    fd=open(argv[1],O_RDONLY);
    if(fd==-1)
    {
        perror("打开文件1失败:");
        return -1;
    }
    fd_cp=open(argv[2],O_WRONLY | O_CREAT | O_TRUNC,0664);
    if(fd_cp==-1)
    {
        perror("打开文件2失败:");
        return -1;
    }
    
    // ssize_t write(int fd, const void *buf, size_t count);
    // 功能：将buf指向的地址中count个字节，写入到fd指向的文件中
    // 参数1：文件描述符
    // 参数2：容器起始地址，void*类型，表明可以写入任何类型的数据
    // 参数3：要写入数据的个数
    // 返回值：成功返回写入的字符个数，失败返回-1并置位错误码

    // ssize_t read(int fd, void *buf, size_t count);
    // 功 能：从fd文件中，将count个字节读取到buf对应的容器中
    // 参数1：文件描述符
    // 参数2：容器起始地址，void*类型，表明可以读取任何类型的数据
    // 参数3：要读取数据的个数
    // 返回值：成功返回读取字节的个数，失败返回-1并置位错误码

    //循环写入
    char buff[4096];
    int res;
    while((res=read(fd,buff,sizeof(buff)))>0)
    {
        write(fd_cp,buff,res);
    }
    //关闭文件
    close(fd);
    close(fd_cp);
}
  1. 将stat函数实现一遍
#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//定义文件属性类型的数据
	struct stat sb;      //用于存储获得的文件属性
 
	//调用函数的到文件属性
	stat(argv[1], &sb);
 
	switch(sb.st_mode&S_IFMT)
	{
	case S_IFSOCK:
		{
			printf("这是套接字文件\t");
		}
		break;
	case S_IFLNK:
		{
			printf("这是链接文件\t");
		}
		break;
	case S_IFREG:
		{
			printf("这是普通文件\t");
		}
		break;
	case S_IFBLK:
		{
			printf("这是块设备文件\t");
		}
		break;
	case S_IFDIR:
		{
			printf("这是目录文件\t");
		}
		break;
	case S_IFCHR:
		{
			printf("这是字符设备文件\t");
		}
		break;
	case S_IFIFO:
		{
			printf("这是管道文件\t");
		}
		break;
 
	}
 
	printf("%#o\t%ld\t%ld\n", sb.st_mode&0777, sb.st_size, sb.st_ino);
 
	return 0;
}
  1. 将目录操作实现一遍
#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//判断外部传参个数
	if(argc != 2)
	{
		printf("input error\n");
		printf("usage:./a.out name\n");
		return -1;
	}
 
	//定义目录指针
	DIR *dp = NULL;
	//打开目录
	if((dp = opendir(argv[1])) == NULL)
	{
		perror("opendir error");
		return -1;
	}
 
	//读取目录中的文件或目录信息
	struct dirent *sdp = NULL;
	while((sdp = readdir(dp)) != NULL)
	{
		//输出当前文件或目录的信息
		printf("inode:%10ld, size:%10d, %10s, ",\
				sdp->d_ino, sdp->d_reclen, sdp->d_name);
 
		//输出类型
		switch(sdp->d_type)
		{
		case DT_BLK:
			{
				printf("b\n");
			}
			break;
	case DT_CHR:
			{
				printf("c\n");
			}
			break;
 
	case DT_DIR:
			{
				printf("d\n");
			}
			break;
 
	case DT_FIFO:
			{
				printf("p\n");
			}
			break;
	case DT_LNK:
			{
				printf("l\n");
			}
			break;
	case DT_REG:
			{
				printf("-\n");
			}
			break;
	case DT_SOCK:
			{
				printf("s\n");
			}
			break;
		}
	}
 
 
 
 
 
	//关闭目录
	closedir(dp);
 
	return 0;
}

笔记

三、文件IO

  1. 文件IO是基于系统调用
  2. 程序每进行一次系统调用，就会从用户空间向内核空间进行一次切换，执行效率较慢
  3. 目的：由于后期进程间通信，如管道、套接字通信，都使用的是文件IO，所以引入文件IO操作的概念

3.1 文件描述符

  1. 件描述符本质上是一个非负整数，每个打开的文件，都会对应一个整数用于系统调用
  2. 每个程序打开文件的个数是有上限的，默认是1024个，可以通过ulimit -a进行查看
  3. 文件描述符使用原则：最小未分配原则
  4. 当使用open函数打开一个文件时，系统会给该文件分配一个文件描述符作为句柄
  5. 当一个程序运行时，默认会打开三个文件描述符，分别对应标准输入、标准输出、标准出错
#include<stdio.h>
 
int main(int argc, const char *argv[])
{
	printf("%d\n", stdin->_fileno);     //0
	printf("%d\n", stdout->_fileno);    //1
	printf("%d\n", stderr->_fileno);    //2
 
	return 0;
}

3.2 open函数

       #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);
        功能：打开或可能创建一个文件
       参数1：文件路径，是一个字符串表示要打开的文件
       参数2：打开标识
               三个必须选一个：O_RDONLY(只读)、O_WRONLY(只写)、O_RDWR(读写)
               后面的可以以位或的方式连接，表示拥有该属性
               O_CREAT：表示创建一个文件， 当第二个参数中有O_CREAT时，第三个参数必须要加上
               O_APPEND:追加方式打开文件
               O_TRUNC:清空文件内容
               O_NONBLOCK:以非阻塞形式打开文件
               O_EXCL:确保本次操作一定创建文件，如果文件已经存在，则open函数会报错，错误码为EEXIST
               eg:    "w": O_WRONLY | O_CREAT | O_TRUNC
                      "r":O_RDONLY
                      "a":O_WRONLY | O_APPEND | O_CREAT  
                      "w+":O_RDWR | O_CREAT | O_TRUNC
                      "r+":O_RDWR
                      "a+":O_RDWR | O_CREAT | O_APPEND
        参数3：如果第二个参数中有O_CREAT,该参数必须设置，表示文件的权限，如果不设置，该文件的权限是一个随机权限
                文件最终的权限是由给定的权限 & ~umask 得到
                终端的umask的值，可以通过指令 umask查看，可以通过指令 umask -n更改当前终端的umask的值
                一般创建普通文件最大权限为：664
                目录文件权限最大权限为：775
        
        返回值：成功返回一个新的文件描述符，失败返回-1并置位错误码。

3.3 close函数

       #include <unistd.h>
 
       int close(int fd);
功能：关闭指定的文件描述符
参数：要关闭的文件描述符，关闭后，该文件描述符可以分配给其他文件使用
返回值：成功返回0，失败返回-1并置位错误码

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	int fd = -1;      //定义文件描述符变量
 
	fd = open("./test.txt", O_WRONLY|O_CREAT|O_TRUNC, 0664);
	if(fd == -1)
	{
		perror("open error");
		return -1;
	}
 
	printf("fd = %d\n", fd);            //？3
 
	//关闭文件描述符
	close(fd);
	
 
 
 
	return 0;
}

3.4 write\read函数

       #include <unistd.h>
 
       ssize_t write(int fd, const void *buf, size_t count);
功能：将buf指向的地址中count个字节，写入到fd指向的文件中
参数1：文件描述符
参数2：容器起始地址，void*类型，表明可以写入任何类型的数据
参数3：要写入数据的个数
返回值：成功返回写入的字符个数，失败返回-1并置位错误码
 
 
       #include <unistd.h>
 
       ssize_t read(int fd, void *buf, size_t count);
功能：从fd文件中，将count个字节读取到buf对应的容器中
参数1：文件描述符
参数2：容器起始地址，void*类型，表明可以读取任何类型的数据
参数3：要读取数据的个数
返回值：成功返回读取字节的个数，失败返回-1并置位错误码

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//定义文件描述符变量
	int fd = -1;
 
	//以只写的形式打开文件
	if((fd = open("./test.txt", O_WRONLY|O_CREAT|O_TRUNC, 0664)) ==-1)
	{
		perror("open error");
		return -1;
	}
	printf("fd = %d\n", fd);             //3
 
	char buf[128] = "hello world ni hao I love China\n";
	//将字符串写入到文件
	int res = write(fd, buf, strlen(buf));
	printf("res = %d\n", res);                //
 
	//关闭文件
	close(fd);
 
	//以只读的形式打开文件
	if((fd = open("./test.txt", O_RDONLY)) ==-1)
	{
		perror("open error");
		return -1;
	}
	printf("fd = %d\n", fd);             //3
 
	char rbuf[128] = "";
	res = read(fd, rbuf, sizeof(rbuf));
	printf("res = %d\n", res);                //?
	write(stdout->_fileno, rbuf, res);
 
	//关闭文件
	close(fd);
 
 
 
 
	return 0;
}

练习：使用read、wriet完成两个文件的拷贝

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//判断传入的文件个数
	if(argc != 3)
	{
		printf("input file error\n");
		printf("usage:./a.out srcfile dstfile\n");
		return -1;
	}
 
	//定义文件描述符变量
	int srcfd, dstfd;
 
	//以只读的形式打开源文件
	if((srcfd = open(argv[1], O_RDONLY)) ==-1)
	{
		perror("open srcfile error");
		return -1;
	}
	//以只写的形式打开目标文件
	if((dstfd = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0664)) ==-1)
	{
		perror("open dstfile error");
		return -1;
	}
	
	//不断得将源文件中的内容读出，并写入的目标文件中
	//直到源文件全部读取结束
	char buf[128] = "";
	while(1)
	{
 
		memset(buf, 0, sizeof(buf));    //将容器清空
 
		int res = read(srcfd, buf, sizeof(buf));   //从源文件中读取数据
 
		write(dstfd, buf, res);     //将数据写入目标文件
 
		//对读取的数据个数进行判断
		if(res == 0)
		{
			break;
		}
	}
	
 
	//关闭两个文件
	close(srcfd);
	close(dstfd);
 
	printf("拷贝成功\n");
 
	return 0;
}

3.5 光标移动（lseek）

       #include <sys/types.h>
       #include <unistd.h>
 
       off_t lseek(int fd, off_t offset, int whence);
功能：移动光标位置
参数1：要移动光标的文件描述符
参数2：偏移量
        >0:表示向后偏移
        =0:表示不偏移
        <0:表示向前偏移
参数3：偏移的起始位置
        SEEK_SET：从文件开头偏移
        SEEK_CUR：从文件光标当前位置偏移
        SEEK_END：从文件末尾开始偏移
返回值：成功返回光标当前位置，失败返回（off_t）-1并置位错误码
        lseek = fseek + ftell

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//定义文件描述符变量
	int fd = -1;
	
	//以只读的形式打开图片文件
	if((fd = open("./bb.bmp", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
	
	//读取图像的大小
	//偏移2个自己
	lseek(fd, 2, SEEK_SET);
	//读取数据
	unsigned int size;
	read(fd, &size, sizeof(unsigned int));
	printf("size = %d\n", size);              //?
 
 
	size = lseek(fd, 0, SEEK_END);         //将光标定位在结尾，将光标位置返回
	printf("size = %d\n", size);              //?
	
	//关闭文件
	close(fd);
 
	return 0;
}

3.6 关于文件描述符的拷贝问题

1> 使用赋值的情况直接拷贝，多个文件描述符变量，共享同一个文件光标，通过一个文件描述符进行移动，所有的文件描述符的光标都会改变

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//以只读的形式打开一个文件
	int fd1 = -1;
	if((fd1 = open("./test.txt", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
 
	printf("fd1 = %d\n", fd1);    //3
 
	int fd2 = fd1;             //对文件描述符直接进行拷贝
	
	//使用fd1将光标后移10个字节
	lseek(fd1, 12, SEEK_SET);
 
	//从fd2中读取数据
	char buf[10] = "";
	read(fd2, buf, sizeof(buf)-1);
	
	printf("buf = %s\n", buf);     //如果输出的是hello开头的，说明fd1和fd2不共享文件光标
					//如果输出的是ni hao开头的，说明fd1和fd2共享同一个文件光标
 
 
 
	return 0;
}

2> 使用dup函数，完成文件描述符的拷贝

       #include <unistd.h>
 
       int dup(int oldfd);
功能：通过旧的文件描述符，拷贝出一个新的文件描述符，新文件描述符遵循最小未分配原则
参数：旧文件描述符
返回值：新文件描述符，失败返回-1并置位错误码
执行后，新旧两个文件描述符都指向同一个打开的文件，共享文件光标位置

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//以只读的形式打开一个文件
	int fd1 = -1;
	if((fd1 = open("./test.txt", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
 
	printf("fd1 = %d\n", fd1);    //3
 
 
	int fd2 = dup(fd1);      //拷贝旧文件描述符，产生一个新文件描述符
	printf("fd2 = %d\n", fd2);      //4
 
	//使用fd1将光标后移10个字节
	lseek(3, 12, SEEK_SET);
 
	//从fd2中读取数据
	char buf[10] = "";
	read(4, buf, sizeof(buf)-1);
	
	printf("buf = %s\n", buf);     //如果输出的是hello开头的，说明fd1和fd2不共享文件光标
								//如果输出的是ni hao开头的，说明fd1和fd2共享同一个文件光标
 
 
 
	return 0;
}

3> 使用dup2函数完成两个文件描述符的拷贝

        int dup2(int oldfd, int newfd);
功能：通过拷贝旧的文件描述符到新的文件描述符中
参数1：旧文件描述符
参数2：新文件描述符，如果newfd已经指向了某个已经打开的文件，则在进行拷贝之前，先将其关闭
返回值：成功返回新的文件描述符，失败返回-1并置位错误码
注意：newfd不是使用最小为分配原则，因为newfd在调用之前可能已经指向某个文件，调用后，无论是newfd函数oldfd都指向oldfd指向的文件
        通过该方式复制的文件描述符，依然共享同一个文件的光标

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//以只读的形式打开一个文件
	int fd1 = -1;
	if((fd1 = open("./test.txt", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
 
 
	//定义一个文件描述符变量，打开另一个文件
	int fd2 = -1;
	if((fd2 = open("./bb.bmp", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
 
	printf("fd1 = %d\n", fd1);    //3
	printf("fd2 = %d\n", fd2);    //4
 
	//执行文件描述符拷贝工作
	dup2(fd1, fd2);
 
 
 
 
	//使用fd1将光标后移10个字节
	lseek(3, 12, SEEK_SET);
 
	//从fd2中读取数据
	char buf[10] = "";
	read(4, buf, sizeof(buf)-1);
	
	printf("buf = %s\n", buf);     //如果输出的是hello开头的，说明fd1和fd2不共享文件光标
									//如果输出的是ni hao开头的，说明fd1和fd2共享同一个文件光标
 
 
 
	return 0;
}

4> 多次使用open函数完成对同一个文件的打开时，不同的文件描述符使用的是独立的光标

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//以只读的形式打开一个文件
	int fd1 = -1;
	if((fd1 = open("./test.txt", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
 
 
	//定义一个文件描述符变量，打开另一个文件
	int fd2 = -1;
	if((fd2 = open("./test.txt", O_RDONLY)) == -1)
	{
		perror("open error");
		return -1;
	}
 
	printf("fd1 = %d\n", fd1);    //3
	printf("fd2 = %d\n", fd2);    //4
 
	//使用fd1将光标后移10个字节
	lseek(fd1, 12, SEEK_SET);
 
	//从fd2中读取数据
	char buf[10] = "";
	read(fd2, buf, sizeof(buf)-1);
	
	printf("buf = %s\n", buf);     //如果输出的是hello开头的，说明fd1和fd2不共享文件光标
								//如果输出的是ni hao开头的，说明fd1和fd2共享同一个文件光标
 
 
 
	return 0;
}

四、文件属性获取（stat）

       #include <sys/types.h>
       #include <sys/stat.h>
       #include <unistd.h>
 
       int stat(const char *pathname, struct stat *statbuf);
 
功能：将给定的文件的相关属性，通过statbuf返回出来
参数1：要获取属性的文件路径是一个字符串
参数2：文件属性结构体指针，需要传递一个文件属性类型的结构体变量
        文件属性结构体类型：
            struct stat {
               dev_t     st_dev;         /* ID of device containing file */   设备id号
               ino_t     st_ino;         /* Inode number */       文件的inode号
               mode_t    st_mode;        /* File type and mode */   文件的类型和权限
               nlink_t   st_nlink;       /* Number of hard links */  硬链接数
               uid_t     st_uid;         /* User ID of owner */      用户id号
               gid_t     st_gid;         /* Group ID of owner */     组id号
               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 */   块的个数               
           };
           关于文件类型和文件权限的介绍
           使用 st_mode &  S_IFMT后的到文件的类型
           S_IFSOCK   0140000   socket           套接字文件类型
           S_IFLNK    0120000   symbolic link    链接文件类型 
           S_IFREG    0100000   regular file     普通文件类型
           S_IFBLK    0060000   block device     块设备文件类型
           S_IFDIR    0040000   directory        目录文件类型 
           S_IFCHR    0020000   character device 字符设备文件类型
           S_IFIFO    0010000   FIFO              管道文件类型
           
           使用 st_mode & 0777后得到文件的权限
返回值：成功返回0，失败返回-1并置位错误码                        
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//定义文件属性类型的数据
	struct stat sb;      //用于存储获得的文件属性
 
	//调用函数的到文件属性
	stat(argv[1], &sb);
 
	switch(sb.st_mode&S_IFMT)
	{
	case S_IFSOCK:
		{
			printf("这是套接字文件\t");
		}
		break;
	case S_IFLNK:
		{
			printf("这是链接文件\t");
		}
		break;
	case S_IFREG:
		{
			printf("这是普通文件\t");
		}
		break;
	case S_IFBLK:
		{
			printf("这是块设备文件\t");
		}
		break;
	case S_IFDIR:
		{
			printf("这是目录文件\t");
		}
		break;
	case S_IFCHR:
		{
			printf("这是字符设备文件\t");
		}
		break;
	case S_IFIFO:
		{
			printf("这是管道文件\t");
		}
		break;
 
	}
 
	printf("%#o\t%ld\t%ld\n", sb.st_mode&0777, sb.st_size, sb.st_ino);
 
	return 0;
}

五、目录相关操作

5.1 opendir函数

       #include <sys/types.h>
       #include <dirent.h>
 
       DIR *opendir(const char *name);
功能：打开一个指定的目录，并返回该目录的目录指针
参数：要打开的目录，是一个字符串
返回值：成功返回目录指针，失败返回NULL并置位错误码

5.2 closedir函数

       #include <sys/types.h>
 
       #include <dirent.h>
 
       int closedir(DIR *dirp);
功能：关闭一个已经打开的目录指针
参数：目录指针
返回值：成功返回0，失败返回-1并置位错误码

5.3 readdir函数

       #include <dirent.h>
 
       struct dirent *readdir(DIR *dirp);
功能：读取指定目录中的下一个文件或目录的信息
参数：目录指针
返回值：成功返回当前文件或目录的信息，失败返回NULL并置位错误码
struct dirent {
               ino_t          d_ino;       /* Inode number */         //当前目录或文件的inode号   8字节
               off_t          d_off;       /* Not an offset; see below */   光标偏移量            8字节
               unsigned short d_reclen;    /* Length of this record */       当前记录的大小       2字节
               unsigned char  d_type;      /* Type of file; not supported     文件类型            1字节
                                              by all filesystem types */
               char           d_name[256]; /* Null-terminated filename */     文件名
           };
           
            关于文件或目录类型
              DT_BLK      This is a block device.
 
              DT_CHR      This is a character device.
 
              DT_DIR      This is a directory.
 
              DT_FIFO     This is a named pipe (FIFO).
 
              DT_LNK      This is a symbolic link.
 
              DT_REG      This is a regular file.
 
              DT_SOCK     This is a UNIX domain socket.
 
              DT_UNKNOWN  The file type could not be determined.
 
 
 

#include<myhead.h>
 
int main(int argc, const char *argv[])
{
	//判断外部传参个数
	if(argc != 2)
	{
		printf("input error\n");
		printf("usage:./a.out name\n");
		return -1;
	}
 
	//定义目录指针
	DIR *dp = NULL;
	//打开目录
	if((dp = opendir(argv[1])) == NULL)
	{
		perror("opendir error");
		return -1;
	}
 
	//读取目录中的文件或目录信息
	struct dirent *sdp = NULL;
	while((sdp = readdir(dp)) != NULL)
	{
		//输出当前文件或目录的信息
		printf("inode:%10ld, size:%10d, %10s, ",\
				sdp->d_ino, sdp->d_reclen, sdp->d_name);
 
		//输出类型
		switch(sdp->d_type)
		{
		case DT_BLK:
			{
				printf("b\n");
			}
			break;
	case DT_CHR:
			{
				printf("c\n");
			}
			break;
 
	case DT_DIR:
			{
				printf("d\n");
			}
			break;
 
	case DT_FIFO:
			{
				printf("p\n");
			}
			break;
	case DT_LNK:
			{
				printf("l\n");
			}
			break;
	case DT_REG:
			{
				printf("-\n");
			}
			break;
	case DT_SOCK:
			{
				printf("s\n");
			}
			break;
		}
	}
 
 
 
 
 
	//关闭目录
	closedir(dp);
 
	return 0;
}

img

BH6AEV
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
嵌入式实习-day4-结构体、文件IO与进程
11-20
今天主要资源内容 ...3、进程 作业：1、使用文件IO，实现文件的拷贝 2、分析程序运行结果，并写明原因 int main() { printf("hello world"); int i; for(i = 0; i < 3; i++) { fork(); } }
嵌入式实习-day2-计算机的基本结构
11-20
3. **存储器**：存储器分为两种主要类型：内存（RAM）和外存（硬盘、闪存等）。内存是临时存储运行中的程序和数据的地方，断电后数据会丢失。外存则用于长期保存信息，即使断电数据也不会丢失。内存又分为只读存储器...
嵌入式学习-IO进程线程-Day2
weixin_51597107的博客
01-02 417
i指input o指outputIO就是指程序对外部设备进行信息交换的过程指向文件地址的一个指针，头文件是stdio.h，是结构体类型，用于描述整个文件啊信息，是文件操作的句柄。包含了一个缓冲区，和一个用于系统调用的文件描述符。
嵌入式学习-IO进程线程-Day4
weixin_51597107的博客
01-04 456
标准IO：依赖于库函数（程序提供的函数），该函数内封装了缓冲区，调用该函数时先将操作的数据放入缓冲区，待刷新时机到了后，调用系统调用函数将数据统一刷入到内核空间，效率较高。是基于文件指针的操作文件IO：依赖于系统调用（室内和提供的函数），每次进行该调用时都会执行一次系统调用，效率较低。是基于文件描述符（整形数据）的操作。标准IO=文件IO+缓冲区。
嵌入式学习-IO进程线程-Day1
weixin_51597107的博客
01-01 394
运行结果。
【嵌入式学习】IO进程线程-Day1-IO基础
BH6AEV的博客
01-02 1133
1> 标准IO：printf\scanf、getchar\putchar、gets\puts 、fopen\fclose、fprintf\fscanf、fgetc\fputc、fgets\fputs、fread\fwrite、fseek\ftell\rewind。1> 标准IO：依赖于库函数，程序提供的函数，该函数中封装了一个缓冲区，调用函数时先将要操作的数据放入缓冲区，等待缓冲区刷新时机到了后，该函数在调用系统调用函数将数据同一刷入到内核空间，效率较高。3> 以上函数的特点：输入输出的目标都是终端文件。
【嵌入式学习】IO进程线程-Day2-IO基础
BH6AEV的博客
01-02 433
1> 使用fread、fwrite完成两个文件的拷贝2> 将注册登录框架重新实现一遍3> 完成图像文件信息的读写操作。
嵌入式学习-IO进程线程-Day8
m0_56018621的博客
01-12 795
Day8 思维导图
【嵌入式学习】IO进程线程-Day5-进程线程通信
BH6AEV的博客
01-05 361
4> 使用三个线程完成：线程1输出字符’A’,线程2输出字符’B’,线程3输出字符’C’,要求输出结果为：ABCABCABCABCABC…3> 使用三个线程完成两个文件的拷贝，线程1完成拷贝前一半，线程2完成拷贝后一半，主线程回收两个分支线程的资源。1> 将互斥机制代码重新实现一遍。2> 将同步机制代码重新实现一遍。5> 周末完成C语言基础测试题。
嵌入式学习-IO进程线程-Day3
m0_56018621的博客
01-03 463
【代码】嵌入式学习-IO进程线程-Day3。
嵌入式学习-IO进程线程-Day5
weixin_51597107的博客
01-06 367
运行结果。
LCD1602-DS1302时钟程序设计.doc
06-14
3. **程序结构**：程序包含了多个函数，如初始化函数`LCD1602_Init()`、写入数据到LCD的`WriteData()`和`WriteCommand()`、读取数据的`ReadData()`和`Readbusy()`，以及延迟函数如`Delay5Ms()`和`delayms()`，这些都...
atguigu_Day_01随堂笔记1.pdf
10-04
在JavaSE课程大纲中，学习者将深入掌握Java的基础语法、面向对象编程思想，以及常用API的使用，例如集合框架、输入/输出（IO）操作、多线程编程和网络编程。此外，课程还会涵盖Java 8的新特性，如Lambda表达式、方法...
嵌入式51单片机实时时钟 pcf8563完整代码
06-07
u8 hour,hour1,minute,minute1,second,day,week,week1,month,year; //RTC变量 u16 msecond; u16msecond1; u8hello; u8naofu; u8zhuangtai; u8xunhuan; u8tuinao; //闹钟控制开启退出 u8xinqinao;//...
编程学习之路：从零到一的成长指南
KsuferNotes
07-22 247
在当今数字化时代，编程技能已经成为许多人职业发展的重要组成部分。不论你是已经在IT业从业多年的老手，还是刚刚起步的编程新手，这篇博客将带你走过编程学习的每一个重要阶段，从而顺利完成从零到一的华丽转变。
kubernetes学习日志（七）
qq_47037022的博客
07-18 607
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
学习测试10-3自动化 web自动化
最新发布
qq_44897733的博客
07-22 380
链接: https://pan.baidu.com/s/1QnGEAeP4ASMgdBYbAtSUTg?pwd=8sdd 提取码: 8sdd。性别、生日、出生地、居住地、情感状态、交友目的、血型。复制这段内容后打开百度网盘手机App，操作更方便哦。2、输入用户名，密码，（使用id属性）4、所有信息后的下拉框设置为保密。论坛系统课堂及其课后练习题库。3、基本资料栏位依次输入内容。三、单个注册与连续注册多个。4、实现连续注册10个账号。二、设置用户的真实姓名。
纯前端小游戏，4096小游戏，有音效，Html5，可学习使用
m0_62996549的博客
07-18 467
【代码】纯前端小游戏，4096小游戏，有音效，Html5，可学习使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值