嵌入式学习 18（Linux高级编程——文件 day1）

已于 2024-08-12 22:18:22 修改
阅读量579 收藏 10
点赞数 24
文章标签： linux 学习 java
于 2024-08-12 22:15:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63556308/article/details/141132962
版权

Linux中一切都是文件。

学习使用man指令查询函数功能。

fopen()函数

函数原型：FILE *fopen(const char *pathname, const char *mode);

pathname表示要打开的文件；mode指定打开文件的模式。

例如：FILE * fp = fopen("1.txt","w");

FILE *fp ：定义了一个指向 FILE 类型的指针 fp 。FILE 是 C 语言中用于表示文件的数据结构。

fopen("1.txt", "w") ：这是一个函数调用，用于打开文件。

"w"是文件打开模式。

"1.txt" ：是要打开文件的文件名。

文件打开模式：

  • "w" ：以写入模式打开文件，如果文件不存在，则创建一个新文件；如果文件已存在，则清空文件内容。
  • "r" ：以只读模式打开文件。如果文件不存在，则打开失败。
    例如：FILE *fp = fopen("data.txt", "r"); 用于只读方式打开 data.txt 文件。
  • "a" ：以追加模式打开文件。如果文件不存在，则创建一个新文件。写入的数据会添加到文件末尾。
    比如：FILE *fp = fopen("log.txt", "a"); 可用于向日志文件追加新的记录。
  • "r+" ：以读写模式打开文件。文件必须存在。
    例如：FILE *fp = fopen("file.txt", "r+"); 允许对文件进行读取和写入操作。
  • "w+" ：以读写模式打开文件。如果文件不存在，则创建新文件；如果文件存在，则清空文件内容。
    比如：FILE *fp = fopen("output.txt", "w+"); 常用于创建新文件或覆盖旧文件并进行读写操作。
  • "a+" ：以读写模式打开文件。如果文件不存在，则创建新文件；读取操作从文件开头开始，写入操作则添加到文件末尾。
    例如：FILE *fp = fopen("data_store.txt", "a+"); 适用于既需要读取文件已有内容，又要在末尾添加新数据的情况
#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    FILE * fp = fopen("1.txt","w");  // 以只写模式打开文件"1.txt"，获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }

    return 0;  // 程序正常结束，返回 0
}

fputc(写入) / fgetc（读取）

fputc() 是 C 标准库中的一个函数，用于向文件中写入一个字符。

它的函数原型为：int fputc(int c, FILE *stream)

  • c：要写入的字符。
  • stream：指向要写入的文件的 FILE 指针。

函数返回写入的字符，如果发生错误则返回 EOF（通常被定义为 -1）。

如果要依次写入字符 '1' 到 '9' ：

FILE *fp = fopen("1.txt", "w");
if (fp!= NULL) 
{
    for (int i = '1'; i <= '9'; i++) 
    {
        fputc(i, fp);
    }
    fclose(fp);
}
#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    FILE * fp = fopen("1.txt","w");  // 以只写模式打开文件"1.txt"，获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }

    int ret = fputc('h',fp);  // 向文件中写入字符 'h'，并获取返回值
    if(-1 == ret)  // 如果返回值为 -1，表示写入失败
    {
        printf("fputc error\n");  // 打印"fputc error"
        return 1;  // 程序异常结束，返回 1
    }

    fputc('e',fp);  // 向文件中写入字符 'e'
    fputc('l',fp);  // 向文件中写入字符 'l'
    fputc('l',fp);  // 向文件中写入字符 'l'
    fputc('o',fp);  // 向文件中写入字符 'o'

    fclose(fp);  // 关闭文件

    return 0;  // 程序正常结束，返回 0
}

fgetc() 是 C 标准库中的一个函数，用于从指定的文件流中读取一个字符。

它的函数原型为：int fgetc(FILE *stream)

  • stream：指向要读取的文件流的 FILE 指针。

函数返回读取到的字符，如果到达文件末尾或发生错误，则返回 EOF（通常被定义为 -1）。

#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    FILE * fp = fopen("1.txt","r");  // 以只读模式打开文件"1.txt"，获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }

    while(1)  // 进入一个无限循环
    {
        int c = fgetc(fp);  // 从文件中读取一个字符，并将其值赋给 c
        if(EOF == c)  // 如果读取到文件末尾（EOF）
        {
            break;  // 退出循环
        }
        printf("%c\n",c);  // 打印读取到的字符
    }

    fclose(fp);  // 关闭文件

    return 0;  // 程序正常结束，返回 0
}

 从命令行指定的源文件中读取字符，并将其逐个写入到指定的目标文件中:

#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    if(argc < 3)  // 检查命令行参数的数量是否小于 3
    {
        printf("usage:./a.out srcfile dstfile\n");  // 打印使用说明
        return 1;  // 程序异常结束，返回 1
    }
    FILE *src = fopen(argv[1], "r");  // 以只读模式打开命令行参数中的第一个文件，并获取文件指针
    FILE *dst = fopen(argv[2], "w");  // 以只写模式打开命令行参数中的第二个文件，并获取文件指针
    if(NULL == src || NULL == dst)  // 如果源文件或目标文件打开失败
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }
    while(1)  // 进入一个无限循环
    {
        int c = fgetc(src);  // 从源文件中读取一个字符，并将其值赋给 c
        if(EOF == c)  // 如果读取到源文件末尾（EOF）
        {
            break;  // 退出循环
        }
        fputc(c, dst);  // 将读取到的字符写入到目标文件中
    }

    fclose(dst);  // 关闭目标文件
    fclose(src);  // 关闭源文件

    return 0;  // 程序正常结束，返回 0
}

fputs / fgets

fputs() 是 C 标准库中的一个函数，用于将一个字符串写入到指定的文件流中。

它的函数原型为：int fputs(const char *str, FILE *stream)

  • str：要写入的字符串。
  • stream：指向目标文件的 FILE 指针。

函数返回一个非负值表示成功写入，否则返回 EOF 表示发生错误。

fputs() 常用于将一段文本内容一次性写入文件。

#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    FILE * fp = fopen("1.txt","w");  // 以只写模式打开文件"1.txt"，获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }
    char data[]="hello,world";  // 定义要写入文件的字符串
    int ret = fputs(data,fp);  // 将字符串写入文件，并获取返回值
    if(EOF == ret)  // 如果返回值为 EOF，表示写入失败
    {
        printf("fputs error\n");  // 打印"fputs error"
        return 1;  // 程序异常结束，返回 1
    }
    fclose(fp);  // 关闭文件
    return 0;  // 程序正常结束，返回 0
}

fgets() 是 C 标准库中的一个函数，用于从指定的文件流中读取一行字符串。

它的函数原型为：char *fgets(char *str, int n, FILE *stream)

str：用于存储读取到的字符串的字符数组。

  • n：指定读取的最大字符数（包括字符串结束符 '\0'）。
  • stream：指向要读取的文件流的 FILE 指针。

函数返回值：

  • 成功读取到一行字符串时，返回 str 。
  • 到达文件末尾或发生错误时，返回 NULL 。
#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    FILE * fp = fopen("/etc/passwd","r");  // 以只读模式打开 "/etc/passwd" 文件，并获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }
    char buf[1024]={0};  // 定义一个 1024 字节的字符数组，并初始化为 0 （1k - 4k 通常是常见的缓冲区大小范围）
    while(1)  // 进入一个无限循环
    {
        char* s = fgets(buf, sizeof(buf), fp);  // 从文件中读取一行到 buf 中，并获取返回值
        if(NULL == s)  // 如果返回值为 NULL，表示已到达文件末尾或发生错误
        {
            break;  // 退出循环
        }
        printf("%s\n", buf);  // 打印读取到的这一行
    }
    fclose(fp);  // 关闭文件
    return 0;  // 程序正常结束，返回 0
}

 

#include <stdio.h>  // 包含标准输入输出头文件

int main(int argc, char *argv[])
{
    FILE * fp = fopen("/etc/passwd","r");  // 以只读模式打开 "/etc/passwd" 文件，并获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }

    char buf[1024]={0};  // 定义一个 1024 字节大小的字符数组 buf，并初始化为 0
    while(1)  // 进入一个无限循环
    {
        char* s = fgets(buf, sizeof(buf), fp);  // 从文件中读取一行内容到 buf 中，并获取返回值
        if(NULL == s)  // 如果返回值为 NULL，表示已到达文件末尾或发生错误
        {
            break;  // 退出循环
        }
        printf("%s\n", buf);  // 打印读取到的这一行内容
    }

    fclose(fp);  // 关闭文件

    return 0;  // 程序正常结束，返回 0
}

        这段代码的主要作用是打开指定的文件（/etc/passwd），逐行读取文件内容并将其打印出来，直到读取到文件末尾为止。 

fwrite / fread

        fwrite 函数的原型为 size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) 。

        它的参数包括要写入的数据的指针 ptr 、每个元素的大小 size 、元素的个数 nmemb 和文件指针 stream 。如果成功，该函数返回实际写入的元素总数，这个总数是一个 size_t 类型的整型数据。如果返回值与 nmemb 参数不同，则可能表示出现了错误。

实现将一个结构体 PER 的实例数据写入到一个文件中。

#include <stdio.h>  // 包含标准输入输出头文件
#include <string.h>  // 包含字符串操作头文件

// 定义一个名为 PER 的结构体
typedef struct 
{
    char name[50];  // 用于存储名字的字符数组
    int age;  // 用于存储年龄的整数
    char phone[15];  // 用于存储电话号码的字符数组
}PER;

// 主函数
int main(int argc, char *argv[])
{
    FILE * fp = fopen("1.txt","w");  // 以写入模式打开文件"1.txt"，并获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 返回 1 表示程序异常结束
    }
    PER per;  // 定义 PER 类型的结构体变量 per
    strcpy(per.name, "zhangsan");  // 将字符串"zhangsan"复制到 per 的 name 成员
    per.age = 20;  // 为 per 的 age 成员赋值 20
    strcpy(per.phone, "111222333");  // 将字符串"111222333"复制到 per 的 phone 成员

    size_t ret = fwrite(&per, sizeof(per), 1, fp);  // 将 per 的内容写入文件
    // 如果实际写入的个数不等于期望写入的个数 1
    if(ret!= 1)  
    {
        printf("fwrite error\n");  // 打印"fwrite error"
        return 1;  // 返回 1 表示程序异常结束
    }
    fclose(fp);  // 关闭文件
    return 0;  // 返回 0 表示程序正常结束
}

        fread函数的原型为 size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream) 。

        它的第一个参数 ptr 是指向接收数据的内存地址，第二个参数 size 是每个元素的大小，第三个参数 nmemb 是要读取的元素个数，第四个参数 stream 是文件指针。

#include <stdio.h>  // 包含标准输入输出头文件
#include <string.h>  // 包含字符串处理头文件

// 定义一个名为 PER 的结构体
typedef struct 
{
    char name[50];  // 存储名字的字符数组
    int age;  // 存储年龄的整数
    char phone[15];  // 存储电话号码的字符数组
}PER;

// 主函数
int main(int argc, char *argv[])
{
    FILE * fp = fopen("1.txt","r");  // 以只读模式打开文件"1.txt"，获取文件指针
    if(NULL == fp)  // 如果文件打开失败，文件指针为 NULL
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }
    PER per;
    // memset(&per,0,sizeof(per));  // 注释掉的这行，可用于将 per 所占据的内存初始化为 0
    bzero(&per,sizeof(per));  // 将 per 所占据的内存初始化为 0

    size_t ret = fread(&per,sizeof(per),1,fp);  // 从文件中读取一个结构体大小的数据到 per 中
    printf("name:%s age:%d phone:%s\n",per.name,per.age,per.phone);  // 打印读取到的结构体成员值
    if(ret!= 1)  // 如果实际读取的个数不等于期望读取的个数 1
    {
        printf("fread error\n");  // 打印"fread error"
        return 1;  // 程序异常结束，返回 1
    }
    fclose(fp);  // 关闭文件
    return 0;  // 程序正常结束，返回 0
}
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct 
{
    char name[50];
    int age;
    char phone[15];
}PER;

int main(int argc, char *argv[])
{
    FILE * src_fp = fopen("/home/linux/1.png","r");  // 以只读模式打开源图片文件，并获取文件指针
    FILE*  dst_fp = fopen("2.png","w");  // 以只写模式创建目标图片文件，并获取文件指针
    if(NULL == src_fp || NULL == dst_fp)  // 如果源文件或目标文件打开失败
    {
        printf("fopen error\n");  // 打印"fopen error"
        return 1;  // 程序异常结束，返回 1
    }
    int size = 160743;  // 定义要读取和写入的字节数
    char *p = (char* )malloc(size);  // 动态分配内存用于存储读取的文件内容
    fread(p, size, 1, src_fp);  // 从源文件读取指定字节数的数据到分配的内存中
    fwrite(p, size, 1, dst_fp);  // 将读取的数据写入到目标文件中
    fclose(dst_fp);  // 关闭目标文件
    fclose(src_fp);  // 关闭源文件
    free(p);  // 释放动态分配的内存
    return 0;
}

        这段代码的主要功能是将一个图片文件（/home/linux/1.png）的内容读取到动态分配的内存中，然后将其写入到另一个图片文件（2.png）中。需要注意的是，在实际应用中，对于图片等二进制文件的处理，要确保文件操作的完整性和正确性，并且要注意内存的合理分配和释放，以避免内存泄漏等问题。

 

求学者1.0
关注
  • 24
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[野火]《嵌入式Linux驱动开发实战指南——基于i.MX6ULL系列》
02-08
1. 嵌入式 Linux 驱动开发概述 嵌入式 Linux 驱动开发是指在嵌入式系统中使用 Linux 操作系统来驱动硬件设备的过程。该过程需要熟悉 Linux 内核、驱动程序开发和嵌入式系统的特点。 2. SDK 目录结构 SDK 目录结构是...
韦东山嵌入式Linux学习——002 构建最小根文件系统（2）
01-06
目录根文件系统/proc的完善一、前言二、`/proc`完善方法一：1、新建/proc子目录2、修改配置文件，添加脚本3、创建脚本文件，添加挂载命令三、`/proc`完善方法二：1、在脚本文件中，添加挂载命令2、新建`/etc/
嵌入式学习——Linux高级编程复习（文件IO）——day37
qq_47798402的博客
06-08 1040
文件IO是指文件输入/输出，是计算机程序中用于读取和写入文件的操作。通过文件IO，程序可以从文件中读取数据到内存中，或者将内存中的数据写入文件中，文件可以是磁盘上的普通文件、设备文件（如打印机、磁盘驱动器）、管道、套接字等。文件IO是与外部存储介质（如硬盘、固态硬盘、闪存驱动器等）交互的主要方式，它允许程序与文件系统进行通信，实现数据的持久化存储和读取。文件描述符是操作系统中用于标识一个文件或者其他I/O资源的整数。在Unix-like系统中，每个打开的文件、套接字、管道等都会分配一个唯一的文件描述符。
嵌入式学习——Linux高级编程复习（网络编程）——day42
qq_47798402的博客
06-12 584
每个层次都有明确的功能，提供特定的服务，并通过相邻层的接口与其交互。OSI模型为网络通信提供了一个逻辑分层的框架，便于理解、设计和故障排查，但它更多地作为一个理论模型存在，并未直接转化为实际的网络实现。TCP/IP是一个实际使用的、更为实际的网络通信协议集合，它最初由美国国防部研发，用于互联网的通信。通信双方约定的一套标准称为协议。2. OSI参考模型。
嵌入式学习——Linux高级编程复习（TCP编程）——day44
qq_47798402的博客
06-15 993
type:SOCK_STREAM 流式套接字 tcp传输协议。线程编译gcc要加后缀 -lpthread。成功返回与发送端建立的新文件描述符（通信套接字）addrlen:想要接收地址大小变量空间首地址。addr:存放链接对方地址信息空间首地址。将本地字节序（小端）转换为网络字节序（大端）addrlen:接收方地址的大小。addr:接收方地址空间首地址。1.序列号:发送字节内容在缓存区中的编号(要发送字节的编号)2.确认号:收到字节内容的编号(只有ACK为1时才有确认号)
嵌入式学习——Linux高级编程复习（UDP编程）——day43
qq_47798402的博客
06-15 1023
* port in network byte order */（端口号、小端存储要改成大端存储）sa_family_t sin_family;/* address family: AF_INET */（协议族）struct in_addr sin_addr;type:SOCK_STREAM 流式套接字 tcp传输协议。addrlen:想要接收发送端地址大小的变量空间首地址。src_addr:存放发送端地址信息空间首地址。
嵌入式学习——Linux高级编程复习（HTML编程）——day45
qq_47798402的博客
06-17 143
title>中文测试。这里是测试body测试内容。1.格式 dreamwave。
嵌入式学习——Linux高级编程复习（标准IO）——day36
qq_47798402的博客
06-08 986
流指针的主要作用是跟踪文件的位置，这样在进行文件读写操作时就知道从哪里开始读取或者写入数据。在文件读取时，流指针会自动向前移动，以便指向下一个要读取的数据；你声明一个FILE *fp ，并把fopen(某个文件)返回的值赋予fp这两个动作就相当于建立了一个水龙头，当你用getc(fp)之类的输入函数读取文件字符时就相当于拧开了水龙头，每读取一个字符，这个文件就像水一样的流动一下，fp所指的地址自然就向后移动了一位。"a" 追加只写打开 文件存在追加只写打开,文件不存在创建文件。
嵌入式学习——Linux高级编程复习（进程）——day39
qq_47798402的博客
06-09 641
进程控制块（PCB，Process Control Block）是操作系统中用于描述和控制进程状态和属性的一个重要数据结构。每个活动的进程在操作系统中都有一个对应的PCB，它是进程存在的唯一标识。进程是计算机科学中的一个核心概念，它是操作系统进行资源分配和调度的基本单位，代表了一个正在执行中的程序实例。2. 进程的创建（创建了一片虚拟内存空间、多个进程共用同一片虚拟内存空间，进程空间在实际的物理地址是独立的）用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），
嵌入式学习——Linux高级编程复习（线程）——day40
qq_47798402的博客
06-09 871
线程被包含在进程之中，一个进程可以包含一个或多个线程，每个线程代表进程中的一个执行路径，能够并发或并行执行不同的任务。3.1 引用互斥锁的原因：利用全局变量能够实现两个线程任务通信，线程任务通信操作全局变量可能会引发资源竞争,为避免资源竞争,引入互斥锁机制。互斥锁可以理解为是一种资源，一旦互斥锁被加锁,另外的线程任务无法继续加锁，必须等待互斥锁被解锁,另外的任务才能加锁。2.多线程都在同一进程空间内部,一个线程异常结束,导致进程异常结束,1.多进程各自独立,一个进程异常结束,不会影响其余进程。
嵌入式学习——硬件（Linux内核编程）——day58
qq_47798402的博客
07-04 738
Linux内核是开源的，意味着任何人都可以查看、修改和分发其源代码。在现代计算机系统中，ICACHE和DCACHE通常是处理器内部的一部分，它们通过缓存预取（cache prefetching）和替换策略（cache replacement policies）来优化缓存的命中率，以最大限度地提高系统的性能和响应速度。ICACHE（Instruction Cache）和DCACHE（Data Cache）是计算机体系结构中的两种缓存类型，它们分别用于存储指令和数据，旨在提高处理器访问存储器的效率。
适合嵌入式Linux应用的文件系统——JFFS.pdf
09-07
《适合嵌入式Linux应用的文件系统——JFFS》 嵌入式Linux的应用随着互联网的崛起而备受关注，尤其在近年来，其巨大的市场潜力使之成为研究的重点。在这个领域，一个至关重要的需求就是在断电或备份时能保持数据的...
ATK-DLIMX93嵌入式Linux C应用编程指南
07-08
- **高级功能探索**：除了基础操作外，《ATK-DLIMX93嵌入式Linux C应用编程指南》还介绍了更多进阶技术，比如非阻塞模式下的文件读取、异步IO机制等高级特性。这有助于提升程序性能并扩展应用场景范围。 综上所述，...
高级 IO-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板
最新发布
07-16
高级 IO-嵌入式Linux C应用编程学习
从零开始学习ARM嵌入式系列——Linux驱动开发简介-综合文档
05-24
从零开始学习ARM嵌入式系列——Linux驱动开发简介
人工智能-项目实践-嵌入式-关于嵌入式LINUX网络编程.zip
12-27
在本项目实践中，我们聚焦于“人工智能-项目实践-嵌入式-关于嵌入式LINUX网络编程”，这个主题涉及到Linux操作系统、人工智能技术在嵌入式领域的应用以及网络编程技术。下面将详细阐述这些关键知识点。 首先，让...
嵌入式初学者如何学习嵌入式C高级编程
08-21
学习嵌入式C高级编程是踏入这个领域的坚实第一步。C语言在嵌入式系统中扮演着核心角色，因为它的高效、灵活性和对硬件的直接访问能力。以下是一个建议的学习步骤，旨在帮助初学者逐步掌握嵌入式C编程。 首先，进入...
学习嵌入式Linux开发——韦东山升级版全系列嵌入式视频之总线设备驱动模型代码分析
01-06
今天看了《韦东山升级版全系列嵌入式视频之总线设备驱动模型》这一节的视频，看完之后感觉有一种似懂非懂的感觉，因此我对改节视频对应源码进行分析，结果如下： 函数关系图 原创文章 9获赞 1访问量 388 关注 私...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值