C语言文件的随机读写、块读写、行、字符读写以及格式化输入输出
sinye56 2024-10-28 19:18 4 浏览 0 评论
结构体嵌套练习
在这里我们创建一个结构体数组，该数组有三名老师，每名老师又带有三名同学，我们分别给他们赋值，最后根据老师的名字进行降序排列。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
//结构体类型，每个导师有3个学生
typedef struct Teacher
{
char* tName;//导师
char** stu;//
int age;
}Teacher;
//在createTeacher中分配空间
int createTeacher(Teacher** p, int n1, int n2)
{
if (p==NULL)
{
return -1;
}
Teacher* temp = NULL;//Teacher temp[3]
temp = (Teacher*)malloc(n1 * sizeof(Teacher));
if (temp==NULL)
{
return -2;
}
for (int i = 0; i < n1; i++)
{
//导师
temp[i].tName = (char*)malloc(30);//3个老师
//学生
char** s = (char**)malloc(n2 * sizeof(char*));//3个学生的指针变量
for (int j = 0; j < n2; j++)//给3个学生分配堆空间
{
s[j] = (char*)malloc(30);
}
//直接赋值
temp[i].stu = s;
}
//间接赋值
*p = temp;
return 0;
}
//给成员赋值
void initTeacher(Teacher* p, int n1, int n2)
{
if (p==NULL)
{
return;
}
char buf[30];
for (int i = 0; i < n1; i++)
{
//导师名字
sprintf(buf, "teacher%d%d%d", i, i, i);
strcpy(p[i].tName, buf);
//年龄
p[i].age = 30 + 2 * i;
//学生
for (int j = 0; j < n2; j++)
{
sprintf(buf,"stu%d%d%d%d", i, i, j, j);
strcpy(p[i].stu[j], buf);
}
}
}
//打印结构体成员信息
void printTeacher(Teacher* p, int n1, int n2)
{
if (p==NULL)
{
return;
}
for (int i = 0; i < n1; i++)
{
//年龄
printf("%s[%d]\n", p[i].tName, p[i].age);
//学生
for (int j = 0; j < n2; j++)
{
printf("\t%s", p[i].stu[j]);
}
printf("\n");
}
}
//根据导师名字排序，降序
void sortTeacher(Teacher* p, int n)
{
if (p==NULL)
{
return;
}
Teacher temp;
for (int i = 0; i < n-1; i++)
{
for (int j = i+1; j < n; j++)
{
if (strcmp(p[i].tName,p[j].tName)<0)
{
temp = p[i];
p[i] = p[j];
p[j] = temp;
}
}
}
}
//释放空间,在函数内部把p赋值为NULL
void freeTeacher(Teacher** p, int n1, int n2)
{
if (p==NULL)
{
return;
}
Teacher* temp = *p;
for (int i = 0; i < n1; i++)
{
//释放导师
if (temp[i].tName!=NULL)
{
free(temp[i].tName);
temp[i].tName = NULL;
}
//释放学生
for (int j = 0; j < n2; j++)
{
if (temp[i].stu[j]!=NULL)
{
free(temp[i].stu[j]);
temp[i].stu[j] = NULL;
}
}
if (temp[i].stu != NULL)
{
free(temp[i].stu);
temp[i].stu = NULL;
}
}
if (temp!=NULL)
{
free(temp);
*p = NULL;
}
}
int main()
{
int ret = 0;
int n1 = 3;//导师个数
int n2 = 3;//学生
Teacher* p = NULL;
ret = createTeacher(&p, n1, n2);
if (ret!=0)
{
printf("createTeacher err:%d\n", ret);
return ret;
}
initTeacher(p, n1, n2);//给成员赋值
//打印成员，排序前
printf("排序前：\n");
printTeacher(p, n1, n2);
//根据导师姓名排序，降序
sortTeacher(p, n1);
//打印成员，排序后
printf("排序后\n");
printTeacher(p, n1, n2);
//释放空间，在函数内部把p赋值为null
freeTeacher(&p, n1, n2);
printf("\n");
return 0;
}按照字符读写文件fgetc、fputc的使用
fgetc()：
int fgetc(FILE *stream)参数：
- stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要在上面执行操作的流。
返回值
该函数以无符号 char 强制转换为 int 的形式返回读取的字符，如果到达文件末尾或发生读错误，则返回 EOF。
fputc():
int fputc(int char, FILE *stream)参数：
- char -- 这是要被写入的字符。该字符以其对应的 int 值进行传递。
- stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符的流。
返回值：
如果没有发生错误，则返回被写入的字符。如果发生错误，则返回 EOF，并设置错误标识符。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
int main0301()
{
fputc('a', stdout);//将字符a输出到屏幕,打印普通信息
char ch;
ch = fgetc(stdin);//从键盘输入字符放到ch中
printf("ch=%c", ch);
fprintf(stderr, "%c", ch);//stderr指向屏幕，打印错误信息
fputc(ch, stderr);
return 0;
}
int main0302()
{
FILE* fp = NULL;
//相对路径, / , ./ , ../ linux与windows均可
//vs:编译代码时，相对于项目工程
//直接运行可执行程序，相对于程序
char* p = "aaaaaaaaaa"
"bbbbbbbbbbbb"; //字符串换行
printf("%s\n", p);
fp = fopen("./a.txt", "w+");
if (fp!=NULL)
{
fclose(fp);
fp == NULL;
}
return 0;
}
void my_fputc(char* path)
{
FILE* fp = NULL;
// w+ 表示可写可读方式打开 若文件不存在，则创建文件
// 若文件存在 则清空文件内容再写
fp = fopen(path, "w+");
if (fp==NULL)
{
perror("fopen");
return;
}
//写文件
char buf[] = "Today is saturday";
for (int i = 0; i < strlen(buf); i++)
{
//返回值是成功写入文件的字符
int ch = fputc(buf[i], fp);
printf("ch=%c\n", ch);
}
if (fp!=NULL)
{
fclose(fp);
fp = NULL;
}
}
void my_fgetc(char*path)
{
//以文件读写方式打开，如果文件不存在 打开失败
FILE* fp = fopen(path, "r+");
if (fp==NULL)
{
perror("my_fgetc fopen");
return;
}
char ch;
while (ch=fgetc(fp)!=EOF)
{
printf("%c ", ch);
}
printf("\n");
while (!feof(fp))//文件没有结束执行循环
{
ch = fgetc(fp);
printf("%c ", ch);
}
printf("\n");
if (fp!=NULL)
{
fclose(fp);
fp = NULL;
}
}
int main()
{
// my_fputc("../a.txt");
my_fgetc("../a.txt");
return 0;
}按照行读写文件fputs、fgets
fgets()：
char *fgets(char *str, int n, FILE *stream)- str -- 这是指向一个字符数组的指针，该数组存储了要读取的字符串。
- n -- 这是要读取的最大字符数（包括最后的空字符）。通常是使用以 str 传递的数组长度。
- stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要从中读取字符的流。
fputs():
int fputs(const char *str, FILE *stream)- str -- 这是一个数组，包含了要写入的以空字符终止的字符序列。
- stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了要被写入字符串的流。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
void my_fputs(char* path)
{
FILE* fp = NULL;
// w+ 表示可写可读方式打开 若文件不存在，则创建文件
// 若文件存在 则清空文件内容再写
fp = fopen(path, "w+");
if (fp == NULL)
{
perror("fopen");
return;
}
char* buf[] = { "aaa\n","bbb\n","ccc\n" };
for (int i = 0; i < strlen(buf); i++)
{
//返回值是成功写入文件个数,成功返回0，失败非0
int len = fputs(buf[i], fp);
printf("len=%d\n", len);
}
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
void my_fgets(char* path)
{
//以文件读写方式打开，如果文件不存在 打开失败
FILE* fp = fopen(path, "r+");
if (fp == NULL)
{
perror("my_fgets fopen");
return;
}
char buf[100] = { 0 };
while (!feof(fp))
{
//fgets 的返回值，成功返回读取文件内容
//fgets读取完毕后，字符串末尾自动加0
//会将\n读取，并且以\n作为换行标志
char* p = fgets(buf, sizeof(buf), fp);
printf("buf=%s\n", buf);
printf("%s ",p);
}
printf("\n");
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
int main()
{
my_fputs("../04.txt");
my_fgets("../04.txt");
return 0;
}
按照块读写文件fread、fwrite
fread():
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)- ptr -- 这是指向带有最小尺寸 size*nmemb 字节的内存块的指针。
- size -- 这是要读取的每个元素的大小，以字节为单位。
- nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
- stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输入流。
- 返回值:
成功读取的元素总数会以 size_t 对象返回，size_t 对象是一个整型数据类型。如果总数与 nmemb 参数不同，则可能发生了一个错误或者到达了文件末尾
fwrite():
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)- ptr -- 这是指向要被写入的元素数组的指针。
- size -- 这是要被写入的每个元素的大小，以字节为单位。
- nmemb -- 这是元素的个数，每个元素的大小为 size 字节。
- stream -- 这是指向 FILE 对象的指针，该 FILE 对象指定了一个输出流。
- 返回值:
如果成功，该函数返回一个 size_t 对象，表示元素的总数，该对象是一个整型数据类型。如果该数字与 nmemb 参数不同，则会显示一个错误。
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
typedef struct Stu
{
char name[50];
int id;
}Stu;
void my_fwrite(char*path)
{
FILE* fp = fopen(path, "w+");
if (fp == NULL)
{
perror("my_write fopen");
return;
}
Stu s[3];
char buf[50];
for (int i = 0; i < 3; i++)
{
sprintf(buf, "stu%d%d%d", i, i, i);
strcpy(s[i].name, buf);
s[i].id = i + 1;
}
//按块写文件
//s 写入文件内容的首地址
//sizeof(Stu) 块数据的大小
//3 块数 写文件的数据大小 sizeof(Stu)*3
//fp 文件指针
//返回值 成功写入文件的块数
int ret = fwrite(s, sizeof(Stu), 3, fp);
printf("ret=%d\n", ret);//3
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
void my_fread(char** path)
{
FILE* fp = fopen(path, "r+");
if (fp == NULL)
{
perror("my_fread fopen");
return;
}
Stu s[3];
char buf[50];
for (int i = 0; i < 3; i++)
{
sprintf(buf, "stu%d%d%d", i, i, i);
strcpy(s[i].name, buf);
s[i].id = i + 1;
}
//按块读文件
//s 放文件内容首地址
//sizeof(Stu) 块数据的大小
//3 块数 读文件的数据大小 sizeof(Stu)*3
//fp 文件指针
//返回值 成功读出文件的块数
int ret = fread(s, sizeof(Stu), 3, fp);
printf("ret=%d\n", ret);//3
for (int i = 0; i < 3; i++)
{
printf("%s,%d\n", s[i].name, s[i].id);
}
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
int main()
{
my_fwrite("../05.txt");
my_fread("../05.txt");
return 0;
}
按照格式化读写文件fprintf、fscanf
fprintf()：
int fprintf(FILE *stream, const char *format, ...)fscanf():
int fscanf(FILE *stream, const char *format, ...)#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
void my_fprintf(char**path)
{
FILE* fp = fopen(path, "w+");
if (fp == NULL)
{
perror("my_fprintf fopen");
return;
}
//printf("hello world%d\n", 001);
//fprintf(stdout, "hello world%d\n", 001);//实际结果与上相同
fprintf(fp, "%d %d %d\n", 001,2,3);
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
void my_fscanf(char** path)
{
FILE* fp = fopen(path, "r+");
if (fp == NULL)
{
perror("my_fscanf fopen");
return;
}
//printf("hello world%d\n", 001);
//fprintf(stdout, "hello world%d\n", 001);//实际结果与上相同
int a = 0;
int b = 0;
int c = 0;
fscanf(fp, "%d %d %d\n", &a,&b,&c);
printf("a=%d,b=%d,c=%d\n", a,b,c);
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
int main()
{
my_fprintf("../06.txt");
my_fscanf("../06.txt");
return 0;
}文件的随机读写fseek函数的使用
fseek():
int fseek(FILE *stream, long int offset, int whence)- stream -- 这是指向 FILE 对象的指针，该 FILE 对象标识了流。
- offset -- 这是相对 whence 的偏移量，以字节为单位。
- whence -- 这是表示开始添加偏移 offset 的位置。它一般指定为下列常量之一：
SEEK_SET | 文件的开头 |
SEEK_CUR | 文件指针的当前位置 |
SEEK_END | 文件的末尾 |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
typedef struct Stu
{
char name[50];
int id;
}Stu;
void my_fwrite(char* path)
{
FILE* fp = fopen(path, "w+");
if (fp == NULL)
{
perror("my_write fopen");
return;
}
Stu s[3];
char buf[50];
for (int i = 0; i < 3; i++)
{
sprintf(buf, "stu%d%d%d", i, i, i);
strcpy(s[i].name, buf);
s[i].id = i + 1;
}
//按块写文件
//s 写入文件内容的首地址
//sizeof(Stu) 块数据的大小
//3 块数 写文件的数据大小 sizeof(Stu)*3
//fp 文件指针
//返回值 成功写入文件的块数
int ret = fwrite(s, sizeof(Stu), 3, fp);
printf("ret=%d\n", ret);//3
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
void my_fread(char** path)
{
FILE* fp = fopen(path, "r+");
if (fp == NULL)
{
perror("my_fread fopen");
return;
}
Stu s[3];
Stu temp;//读三个结构体
fseek(fp, 2*sizeof(Stu), SEEK_SET);
//fseek(fp, -1*sizeof(Stu), SEEK_END);
int ret = fread(&temp, sizeof(Stu), 1, fp);
if (ret==1)
{
printf("[temp]=%s,%d\n", temp.name, temp.id);
}
//将文件光标移动到开始位置
//fseek(fp, 0, SEEK_SET);
rewind(fp);//光标置首
//按块读文件
//s 放文件内容首地址
//sizeof(Stu) 块数据的大小
//3 块数 读文件的数据大小 sizeof(Stu)*3
//fp 文件指针
//返回值 成功读出文件的块数
ret = fread(s, sizeof(Stu), 3, fp);
printf("ret=%d\n", ret);//3
for (int i = 0; i < 3; i++)
{
printf("%s,%d\n", s[i].name, s[i].id);
}
if (fp != NULL)
{
fclose(fp);
fp = NULL;
}
}
int main()
{
my_fwrite("../07.txt");
my_fread("../07.txt");
return 0;
}相关推荐
- Linux两种光驱自动挂载的方法
-
环境：CentOS6.4西昆云服务器方式一修改fstab文件/etc/fstab是系统保存文件系统信息?静态文件，每一行描述一个文件系统；系统每次启动会读取此文件信息以确定需要挂载哪些文件系统。参...
- linux系统运维，挂载和分区概念太难?在虚机下操作一次全掌握
-
虚拟机的好处就是可以模拟和学习生产环境的一切操作，假如我们还不熟悉磁盘操作，那先在虚机环境下多操作几次。这次来练习下硬盘扩容操作。虚拟机环境：centos8vm11linux设备命名规则在linux中...
- Linux 挂载 NFS 外部存储 (mount 和 /etc/fstab)
-
mount:手工挂载，下次重启需再重新挂载，操作命令：mount-tnfs-ooptionsserver:/remote/export/local/directory上面命令中，本地目录...
- 在Linux中如何设置自动挂载特定文件系统(示例)
-
Linux...
- Linux环境中的绑定挂载(bind mount)
-
简介：Linux中的mount命令是一个特殊的指令，主要用于挂载文件目录。而绑定挂载（bindmount）命令更为特别。mount的bind选项将第一个目录克隆到第二个。一个目录中的改变将会在...
- Linux挂载CIFS共享 临时挂载 1. 首先
-
如何解决服务器存储空间不足的问题？大家好，欢迎回来。在上一期视频中，我为大家介绍了如何利用Linux挂载来扩容服务器存储空间。这一期视频，我将以Linux为例，教大家如何进行扩容。群辉使用的是Linu...
- Linux 硬盘挂载(服务器重启自动挂载)
-
1、先查看目前机器上有几块硬盘，及已挂载磁盘：fdisk-l能够查看到当前主机上已连接上的磁盘，以及已经分割的磁盘分区。（下面以/dev/vdb磁盘进行分区、挂载为例，挂载点设置为/data）df...
- linux 挂载磁盘
-
在Linux中挂载硬盘的步骤如下：...
- 笨小猪教您Linux磁盘挂载
-
本教程针对Linux系统比较熟悉或者想学习Linux基础的用户朋友，本教程操作起来比较傻瓜式，跟着步骤就会操作，本文使用的工具是XShell同时多多注意空格（文中会有提示）。【问答】什么是磁盘挂载？答...
- Linux 磁盘挂载和docker安装命令
-
本篇给大家介绍Linux磁盘挂载和docker安装的相关内容，Linux服务器的操作是一个手熟的过程，一些不常用的命令隔断时间就忘记了，熟话说好记性不如烂笔头，还需在平时的工作中多练习记录。...
- Linux设置开机自动挂载分区
-
有时候，我们在安装完Linux系统之后，可能在使用过程中添加硬盘或者分区进行使用，这时候就需要手动把磁盘分区挂载到某个路径，但是开机之后就会消失，需要重新挂载，非常麻烦，那么我们应该如何设置开机自动挂...
- 在linux挂载一个新硬盘的完整步骤
-
以下是在Linux中挂载新原始磁盘的完整步骤，包括分区、创建文件系统以及使用UUID在/etc/fstab中启动时挂载磁盘：将新的原始磁盘连接到Linux系统并打开电源。运行以下命令，...
- Linux系统如何挂载exFAT分区
-
简介：Linux系统中不能像Windows系统那样自动识别加载新设备，需要手动识别，手动加载。Linux中一切皆文件。文件通过一个很大的文件树来组织，文件树的根目录是：/，从根目开始录逐级展开。这些文...
- Linux系统挂载硬盘
-
fdisk-l查看可挂载的磁盘都有哪些df-h查看已经挂载的磁盘...
- WSL2发布，如何在Win10中挂载Linux文件系统
-
WSL2是最新版本的架构，它为Windows子系统提供支持，使其能够在Windows上运行ELF64Linux二进制文件。通过最近的更新，它允许使用Linux文件系统访问存储在硬盘中的文件。如果你...
欢迎 你 发表评论:
- 一周热门
- 最近发表
- 标签列表
-
- oracle忘记用户名密码 (59)
- oracle11gr2安装教程 (55)
- mybatis调用oracle存储过程 (67)
- oracle spool的用法 (57)
- oracle asm 磁盘管理 (67)
- 前端 设计模式 (64)
- 前端面试vue (56)
- linux格式化 (55)
- linux图形界面 (62)
- linux文件压缩 (75)
- Linux设置权限 (53)
- linux服务器配置 (62)
- mysql安装linux (71)
- linux启动命令 (59)
- 查看linux磁盘 (72)
- linux用户组 (74)
- linux多线程 (70)
- linux设备驱动 (53)
- linux自启动 (59)
- linux网络命令 (55)
- linux传文件 (60)
- linux打包文件 (58)
- linux查看数据库 (61)
- linux获取ip (64)
- 关闭防火墙linux (53)