AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C语言进阶⑱(文件上篇)(动态通讯录写入文件)(文件指针+IO流+八个输入输出函数)fopen+fclose（下）

2024-05-20 62
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C语言进阶⑱(文件上篇)(动态通讯录写入文件)(文件指针+IO流+八个输入输出函数)fopen+fclose

4.3文本行输出函数 fputs

介绍：将字符串写入到指定的流 stream 中（不包括空字符）。适用于所有输出流。

代码演示：利用 fputs 在 test2.txt 中随便写入几行数据：

 
#include <stdio.h>
int main() 
{
    FILE* pf = fopen("test2.txt", "w");
    if (pf == NULL) 
    {
        perror("fopen");
        return 1;
    }
    // 写文件 - 按照行来写
    fputs("abcdef\n", pf);//文件里也会显示换行效果
    fputs("123456", pf);
    // 关闭文件
    fclose(pf);
    pf = NULL;
    return 0;
}

4.4文本行输入函数 fgets

介绍：从指定的流 stream 读取一行，并把它存储在 string 所指向的字符串中，当读取（n-1）个字符时，或者读取到换行符、到达文件末尾时，它会停止，具体视情况而定。适用于所有输入流。


注意事项：假如 n 是100，读取到的就是99个字符（n-1），因为要留一个字符给\0。


代码演示：利用 fgets 读取 test2.txt 中的内容：

 
#include <stdio.h>
int main() 
{
    char arr[10] = "xxxxxx"; // 存放处
    FILE* pf = fopen("test2.txt", "r");
    if (pf == NULL) 
    {
        perror("fopen");
        return 1;
    }
    // 读文件 - 按照行来读
    fgets(arr, 4, pf);
    printf("%s\n", arr);
    fgets(arr, 4, pf);
    printf("%s\n", arr);
    // 关闭文件
    fclose(pf);
    pf = NULL;
    return 0;
}

4.5格式化输出函数 fprintf

介绍：fprintf 用于对格式化的数据进行写文件，发送格式化输出到流 stream 中。适用于所有输出流。

只需要在第一个函数参数放上一个文件指针，后面就和printf一样了。

代码演示：将结构体的三个数据利用 fprintf 写到 test3.txt 中：

 
#include <stdio.h>
struct student
{
    char name[10];
    int age;
    float x;
};
int main()
{
    struct student s = { "GR", 19, 3.14f };
    // 对格式化的数据进行写文件
    FILE* pf = fopen("test3.txt", "w");
    if (pf == NULL) 
    {
        perror("fopen");
        return 1;
    }
    // 写文件
    fprintf(pf, "%s %d %f", s.name, s.age, s.x);
 
    // 关闭文件
    fclose(pf);
    pf = NULL;
 
    return 0;
}

4.6格式化输入函数 fscanf

介绍：fscanf 用于对格式化的数据进行读取，从流 stream 读取格式化输入。适用于所有输入流。

只需要在第一个函数参数放上一个文件指针，后面就和scanf一样了。

代码演示：利用 fscanf 读取刚才 test3.txt 中的内容，并打印：

 
#include <stdio.h>
struct student 
{
    char name[10];
    int age;
    float x;
};
int main() 
{
    struct student s = { 0 }; // 存放处
 
    // 对格式化的数据进行写文件
    FILE* pf = fopen("test3.txt", "r");
    if (pf == NULL) 
    {
        perror("fopen");
        return 1;
    }
    // 读文件
    fscanf(pf, "%s %d %f",s.name, &(s.age), &(s.x)); //  s.name本身就是地址（不用&）
 
    // 将读到的数据打印
    printf("%s %d %f\n", s.name, s.age, s.x);
 
    // 关闭文件
    fclose(pf);
    return 0;
}

4.7二进制输出函数 fwrite

介绍：写一个数据到流中去，把 buffer 所指向的数组中的数据写入到给定流 stream 中。

const void *buffer : 指针指向要写出数据的内存首地址 ;

size_t size : 要写出数据的 基本单元 的字节大小 , 写出单位的大小 ;

size_t count : 要写出数据的 基本单元 的个数 ;

FILE *stream : 打开的文件指针 ;

返回值说明 : size_t 返回值返回的是实际写出到文件的 基本单元 个数 ;

创建一个 test4.txt，用 fwrite 写入一个数据到 text4.txt 中去：

 
#include <stdio.h>
struct student 
{
    char name[10];
    int age;
    float x;
};
int main() 
{
    struct student s = { "GR", 19, 3.14f }; // 存放处
 
    FILE* pf = fopen("test4.txt", "w");
    if (pf == NULL) 
    {
        perror("fopen");
        return 1;
    }
    //写文件
    fwrite(&s, sizeof(struct student), 1, pf);
 
    // 关闭文件
    fclose(pf);
    return 0;
}

运行后打开文件后我们发现只有字母看得懂，后面是什么我们看不懂。

① 我们刚才用的都是文本编译器，文本编译器打开二进制形式的文件完全是两种状态。

② 因为字符串以文本形式写进去和以二进制形式写进去是一样的，但是对于整数、浮点数等

来说就不一样了，文本形式写入和二进制形式写入完全是两个概念。

（那么该怎么读呢，我们来看下面的 fread 函数）

4.8二进制输入函数 fread

介绍：从流中读取，从给定流 stream 读取数据到 buffer 所指向的数组中。参数和fwrite一样

用 fread 读取 text4.txt 中的二进制数据：

 
#include <stdio.h>
struct student 
{
    char name[10];
    int age;
    float x;
};
int main() 
{
    struct student s = { 0 }; // 存放处
 
    FILE* pf = fopen("test4.txt", "r");
    if (pf == NULL) 
    {
        perror("fopen");
        return 1;
    }
    // 读文件
    fread(&s, sizeof(struct student), 1, pf);
 
    // 将读到的数据打印
    printf("%s %d %f", s.name, s.age, s.x);
 
    // 关闭文件
    fclose(pf);
    return 0;
}

总结： fwrite 和 fread 是一对，fwrire 写进去用 fread 读。

把动态通讯录写入文件

首先想到，在上一篇动态通讯录基础性应在退出销毁通讯录函数前设置一个保存通讯录到文件的函数。


那么自然，我们也需要打开通讯录的时候自动读入那个文件，每次打开通讯录我们都会运行init_contact函数，因此我们可以在init_contact函数中利用fread函数读入二进制文件。

写一个加载联系人函数：

//加载联系人函数
void load_contact(contact* p)
{
    FILE* pf = fopen("contact.dat", "r");
    if (pf == NULL)
    {
        perror("load_contact");
        return;
    }
    //读文件
    peoinfo tmp = { 0 };
    while (fread(&tmp, sizeof(peoinfo), 1, pf))
    {
        //是否需要增容
        check_capacity(p);
        p->data[p->sz] = tmp;
        p->sz++;
    }
    
    //关闭文件
    fclose(pf);
    pf = NULL;
}

把之前add函数中负责扩容的部分单独提取出来封装为check_capacity函数，

因为负责扩容的部分利用if语句判断了当前是否需要扩容，这是为了读入文件做的准备。

读文件这里有一个难点，我们并不知道这个二进制文件里头有多少个通讯录成员，

可我们是动态扩容的，无法确定当前容量能不能撑得下这些通讯录成员。


可以利用fread函数的返回值，其返回值表示从二进制文件中读入了多少个元素，


利用一个while循环，每次只读一个通讯录成员信息进来，


循环条件为fread函数的返回值不为0（也就是还没读完），那如果容量不够怎么办？


利用check_capacity函数，每次执行时，先执行check_capacity函数，


如果当前容量不足则扩容，然后再利用fread函数从二进制文件中读入通讯录成员的信息。


代码：

test.c

 
//通讯录-静态版本
//1.通讯录中能够存放1000个人的信息
//每个人的信息：
//名字+年龄+性别+电话+地址
//2. 增加人的信息
//3. 删除指定人的信息
//4. 修改指定人的信息
//5. 查找指定人的信息
//6. 排序通讯录的信息
//
//版本2：
//动态增长的版本
//1.通讯录初始化后，能存放3个人的信息
//2.当我们空间的存放满的时候，我们增加2个信息
//3+2+2+2+...
 
//
//版本3
//当通讯录退出的时候，把信息写到文件
//当通讯录初始化的时候，加载文件的信息到通讯录中
//
 
#include"contact.h"
 
void menu()
{
    printf("****************************************\n");
    printf("******     1.add      2.del     ********\n");
    printf("******     3.search   4.modify  ********\n");
    printf("******     5.sort     6.print   ********\n");
    printf("******     0.exit               ********\n");
    printf("****************************************\n");
}
enum option
{
    EXIT,
    ADD,
    DEL,
    SEARCH,
    MODIFY,
    SORT,
    PRINTF
};
int main()
{
    int input = 0;
    //创建通讯录  info(信息)
    contact con;
    //初始化通讯录函数
    init_contact(&con);
    do
    {
        menu();
        printf("请选择：");
        scanf("%d", &input);
        switch (input)
        {
        case ADD:
            add_contact(&con);
            break;
        case DEL:
            del_contact(&con);
            break;
        case SEARCH:
            find_contact(&con);
            break;
        case MODIFY:
            modify_contact(&con);
            break;
        case SORT:
            sort_contact(&con);
            break;
        case PRINTF:
            print_contact(&con);
            break;
        case EXIT:
            save_contact(&con);
            destroy_contact(&con);
            printf("退出程序\n");
            break;
        default:
            printf("选择错误，重新选择\n");
            break;
        }
    } while (input);
    return 0;
}

contact.h

 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>//qsort，perror，动态内存开辟函数
 
#define MAX_NAME 20
#define MAX_SEX 10
#define MAX_TELE 20
#define MAX_ADDR 30
#define DEFAULT_SZ 3 //default 默认
#define INC_SZ 2 //sz增量
//类型的定义
typedef struct peoinfo
{
    char name[MAX_NAME];
    char sex[MAX_SEX];
    int age;
    char tele[MAX_TELE];
    char addr[MAX_ADDR];
}peoinfo;
 
静态版本通讯录
//typedef struct contact
//{
//    peoinfo data[MAX];//存放添加进来的人的信息     
//    int sz;//记录的是当前通讯录中有效信息的个数
//}contact;
 
//动态版本通讯录
typedef struct contact
{
    peoinfo* data;//指向动态开辟的空间，存放添加进来的人的信息
    int sz;//记录的是当前通讯录中有效信息的个数
    int capacity;//记录当前通讯录的最大容量，方便增容
}contact;
 
//初始化通讯录函数
void init_contact(contact* p);
 
//是否需要增容函数
void check_capacity(contact* p);
 
//加载联系人函数
void load_contact(contact* p);
 
//增加联系人函数
void add_contact(contact* p);
 
//保存联系人函数
void save_contact(contact* p);
 
//销毁联系人函数
void destroy_contact(contact* p);
 
//打印联系人函数
void print_contact(const contact* p);
 
//删除联系人函数
void del_contact(contact* p);
 
//查找联系人函数
void find_contact(const contact* p);
 
//修改联系人函数
void modify_contact(contact* p);
 
//排序联系人函数
void sort_contact(contact* p);

contact.c

 
#include"contact.h"
 
初始化通讯录函数   静态版本
//void init_contact(contact* p)
//{
//    p->sz = 0;
//    memset(p->data, 0, sizeof(p->data));
//}
 
//初始化通讯录函数    动态版本
void init_contact(contact* p)
{
    p->data = (peoinfo*)calloc(DEFAULT_SZ, sizeof(peoinfo));
    if (p->data == NULL)
    {
        perror("init_contact");
        return;
    }
    p->sz = 0;//初始化后默认是0
    p->capacity = DEFAULT_SZ;
 
    //加载文件（读文件）
    load_contact(p);
}
//是否需要增容函数
void check_capacity(contact* p)
{
    if (p->sz == p->capacity)
    {
        peoinfo* tmp = (peoinfo*)realloc(p->data, (p->capacity + INC_SZ) * sizeof(peoinfo));
        if (tmp == NULL)
        {
            perror("add_contact");
            printf("增容失败\n");
            return;
        }
        p->data = tmp;
        p->capacity += INC_SZ;
        printf("增容成功\n");
    }
}
//加载联系人函数
void load_contact(contact* p)
{
    FILE* pf = fopen("contact.dat", "r");
    if (pf == NULL)
    {
        perror("load_contact");
        return;
    }
    //读文件
    peoinfo tmp = { 0 };
    while (fread(&tmp, sizeof(peoinfo), 1, pf))
    {
        //是否需要增容
        check_capacity(p);
        p->data[p->sz] = tmp;
        p->sz++;
    }
    
    //关闭文件
    fclose(pf);
    pf = NULL;
}
 
增加联系人函数      静态版本
//void add_contact(contact* p)
//{
//    if (p->sz == MAX)
//    {
//        printf("通讯录已满，无法添加");
//        return;
//    }
//    printf("请输入要添加人的姓名：");
//    scanf("%s", p->data[p->sz].name);
//    printf("请输入要添加人的性别：");
//    scanf("%s", p->data[p->sz].sex);
//    printf("请输入要添加人的年龄：");
//    scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
//    printf("请输入要添加人的电话：");
//    scanf("%s", p->data[p->sz].tele);
//    printf("请输入要添加人的住址：");
//    scanf("%s", p->data[p->sz].addr);
//
//    p->sz++;
//    printf("添加成功\n");
//}
 
//增加联系人函数      动态版本
void add_contact(contact* p)
{
    check_capacity(p);
 
    printf("请输入要添加人的姓名：");
    scanf("%s", p->data[p->sz].name);
    printf("请输入要添加人的性别：");
    scanf("%s", p->data[p->sz].sex);
    printf("请输入要添加人的年龄：");
    scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
    printf("请输入要添加人的电话：");
    scanf("%s", p->data[p->sz].tele);
    printf("请输入要添加人的住址：");
    scanf("%s", p->data[p->sz].addr);
 
    p->sz++;
    printf("添加成功\n");
}
 
//保存联系人函数
void save_contact(contact* p)
{
    FILE* pf = fopen("contact.dat", "w");
    if (pf == NULL)
    {
        perror("save_contact");
        return;
    }
    //写文件
    for (int i = 0;i < p->sz;i++)
    {
        fwrite(p->data + i, sizeof(peoinfo), 1, pf);
    }
    //关闭文件
    fclose(pf);
    pf = NULL;
}
 
//销毁联系人函数
void destroy_contact(contact* p)
{
    free(p->data);
    p->data = NULL;
    p->sz = 0;
    p->capacity = 0;
}
 
//打印联系人函数
void print_contact(const contact* p)
{
    if (p->sz == 0)
    {
        printf("通讯录为空，无法打印\n");
    }
    else
    {
        printf("%-10s  %-10s  %-10s  %-15s  %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
        for (int i = 0;i < p->sz;i++)
        {
            printf("%-10s  %-10s  %-10d  %-15s  %-10s\n",
                p->data[i].name,
                p->data[i].sex,
                p->data[i].age,
                p->data[i].tele,
                p->data[i].addr);
        }
    }
}
 
//查找函数的一部分，删除和修改也要用，只放在这就行
static int find_by_name(contact* p, char name[])
{
    for (int i = 0;i < p->sz;i++)
    {
        if (strcmp(p->data[i].name,name)==0)
        {
            return i;
        }
    }
    return -1;
}
 
//删除联系人函数
void del_contact(contact* p)
{
    if (p->sz == 0)
    {
        printf("通讯录为空，无法删除\n");
    }
    else
    {
        char name[MAX_NAME] = { 0 };
        printf("请输入要删除人的名字：");
        scanf("%s", name);
        int pos = find_by_name(p, name);
        if (pos == -1)
        {
            printf("要删除的人不存在\n");
        }
        else
        {
            for (int i = pos;i < p->sz - 1;i++)
            {
                p->data[i] = p->data[i + 1];
            }
            p->sz--;
            printf("删除成功\n");
        }
    }
}
 
//查找联系人函数
void find_contact(const contact* p)
{
    if (p->sz == 0)
    {
        printf("通讯录为空，无法查找\n");
    }
    else
    {
        char name[MAX_NAME] = { 0 };
        printf("请输入要查找人的名字：");
        scanf("%s", name);
        int pos = find_by_name(p, name);
        if (pos == -1)
        {
            printf("要查找的人不存在\n");
        }
        else
        {
            printf("%-10s  %-10s  %-10s  %-15s  %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
            printf("%-10s  %-10s  %-10d  %-15s  %-10s\n",
                p->data[pos].name,
                p->data[pos].sex,
                p->data[pos].age,
                p->data[pos].tele,
                p->data[pos].addr);
        }
    }
}
 
//修改联系人函数
void modify_contact(contact* p)
{
    if (p->sz == 0)
    {
        printf("通讯录为空，无法查找\n");
    }
    else
    {
        char name[MAX_NAME] = { 0 };
        printf("请输入要修改人的姓名：");
        scanf("%s", name);
        int pos = find_by_name(p, name);
        if (pos == -1)
        {
            printf("要修改的人不存在\n");
        }
        else
        {
            printf("以下是输入要修改人的新信息：\n");
            printf("请输入姓名：");
            scanf("%s", p->data[pos].name);
            printf("请输入性别：");
            scanf("%s", p->data[pos].sex);
            printf("请输入年龄：");
            scanf("%d", &p->data[pos].age);
            printf("请输入电话：");
            scanf("%s", p->data[pos].tele);
            printf("请输入住址：");
            scanf("%s", p->data[pos].addr);
 
            printf("修改成功\n");
        }
    }
}
 
//排序联系人函数
int cmp(void* e1, void* e2)
{
    return strcmp(((peoinfo*)e1)->name, ((peoinfo*)e2)->name);
}
void sort_contact(contact* p)
{
    if (p->sz == 0)
    {
        printf("通讯录为空，无法排序\n");
    }
    else
    {
        qsort(p->data, p->sz, sizeof(peoinfo), cmp);
        printf("按照姓名排序成功\n");
    }
}
 
void sort_contact2(contact* p)//冒泡，比较麻烦，就用qsort了
{
    if (p->sz == 0)
    {
        printf("通讯录为空，无法排序\n");
    }
    else
    {
        for (int i = 0; i < p->sz; i++)
        {
            for (int j = 0; j < p->sz - i - 1; j++)
            {
                if (strcmp((p->data[j].name), (p->data[j + 1].name)) > 0)
                {
                    peoinfo data = p->data[j];
                    p->data[j] = p->data[j + 1];
                    p->data[j + 1] = data;
                }
            }
        }
        printf("按照姓名排序成功\n");
    }
}

本篇完。


328f9598ffb27e2d11bb887142d70c71.gif

文章标签：
C语言
编译器
存储
关键词：
文件io
C语言函数
C语言指针
C语言文件
文件指针
GR鲸鱼
目录
相关文章
LuckiBit
|
1月前
|
存储 NoSQL 编译器
【C语言】指针的神秘探险：从入门到精通的奇幻之旅 !
指针是一个变量，它存储另一个变量的内存地址。换句话说，指针“指向”存储在内存中的某个数据。
LuckiBit
94 3
【C语言】指针的神秘探险：从入门到精通的奇幻之旅 !
LuckiBit
|
1月前
|
存储 编译器 C语言
【C语言】指针大小知多少 ？一场探寻C语言深处的冒险 ！
在C语言中，指针的大小（即指针变量占用的内存大小）是由计算机的体系结构（例如32位还是64位）和编译器决定的。
LuckiBit
61 9
LuckiBit
|
1月前
|
安全 程序员 C语言
【C语言】指针的爱恨纠葛：常量指针vs指向常量的指针
在C语言中，“常量指针”和“指向常量的指针”是两个重要的指针概念。它们在控制指针的行为和数据的可修改性方面发挥着关键作用。理解这两个概念有助于编写更安全、有效的代码。本文将深入探讨这两个概念，包括定义、语法、实际应用、复杂示例、最佳实践以及常见问题。
LuckiBit
46 7
三三是该溜子
|
14天前
|
存储 Java API
【JavaEE】——文件IO（万字长文）
文件路径，文本文件，二进制文件，File类，文件流，字节流（InputStream，OutputStream）字符流(Reader,Writer)
三三是该溜子
18 0
c的前世今生
|
2月前
|
存储 C语言
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中，通过定义结构体并使用指向该结构体的指针，可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存，然后通过指针访问和修改结构体成员，最后用 `free` 释放内存，实现资源的有效管理。
c的前世今生
179 13
c的前世今生
|
2月前
|
存储 程序员 编译器
C 语言数组与指针的深度剖析与应用
在C语言中，数组与指针是核心概念，二者既独立又紧密相连。数组是在连续内存中存储相同类型数据的结构，而指针则存储内存地址，二者结合可在数据处理、函数传参等方面发挥巨大作用。掌握它们的特性和关系，对于优化程序性能、灵活处理数据结构至关重要。
c的前世今生
127 3
土木林森
|
2月前
|
算法 C语言
C语言中的文件操作技巧，涵盖文件的打开与关闭、读取与写入、文件指针移动及注意事项
本文深入讲解了C语言中的文件操作技巧，涵盖文件的打开与关闭、读取与写入、文件指针移动及注意事项，通过实例演示了文件操作的基本流程，帮助读者掌握这一重要技能，提升程序开发能力。
土木林森
147 3
c的前世今生
|
2月前
|
存储 C语言 开发者
C 语言指针与内存管理
C语言中的指针与内存管理是编程的核心概念。指针用于存储变量的内存地址，实现数据的间接访问和操作；内存管理涉及动态分配（如malloc、free函数）和释放内存，确保程序高效运行并避免内存泄漏。掌握这两者对于编写高质量的C语言程序至关重要。
c的前世今生
65 11
c的前世今生
|
2月前
|
存储 算法 程序员
C 语言指针详解 —— 内存操控的魔法棒
《C 语言指针详解》深入浅出地讲解了指针的概念、使用方法及其在内存操作中的重要作用，被誉为程序员手中的“内存操控魔法棒”。本书适合C语言初学者及希望深化理解指针机制的开发者阅读。
c的前世今生
50 4
土木林森
|
2月前
|
程序员 C语言
C语言中的指针既强大又具挑战性，它像一把钥匙，开启程序世界的隐秘之门
C语言中的指针既强大又具挑战性，它像一把钥匙，开启程序世界的隐秘之门。本文深入探讨了指针的基本概念、声明方式、动态内存分配、函数参数传递、指针运算及与数组和函数的关系，强调了正确使用指针的重要性，并鼓励读者通过实践掌握这一关键技能。
土木林森
45 1