嵌入式 IO 2

最新推荐文章于 2023-02-16 20:49:25 发布
最新推荐文章于 2023-02-16 20:49:25 发布
阅读量335 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MYK0030/article/details/128172917
版权

目录

1.标准IO缓冲区

1.1缓冲区的种类

1.2缓冲区的大小

1.3缓冲区的刷新时机

2.fputs/fgets函数使用

2.1fputs/fgets函数接口介绍

2.2fgets的实例（stdin）

2.3使用fgets统计一个文件的行号

2.4fputs使用实例(stderr/fp)

2.5使用fputs和fgets实现文件的拷贝

3.fread/fwrite函数的使用

3.1fread/fwrite函数介绍

3.2fwrite/fread函数使用实例(读写字符串)

3.3fwrite/fread函数使用实例(读写整数)

3.4fwrite/fread函数使用实例(读写结构体)

3.5使用fread/fwrite拷贝文件

4.sprintf/snprintf/fprintf函数的使用

4.1sprintf/snprintf/fprintf函数介绍

4.2sprintf函数实例

4.3snprintf函数实例

4.4fprintf函数实例

5.作业

1.标准IO缓冲区

1.1缓冲区的种类

  1. 全缓存：和文件操作相关的缓冲区就是全缓存(fp)
  2. 行缓存：和终端相关的缓冲区就是行缓存（stdin stdout）
  3. 不缓存（标准出错stderr）

1.2缓冲区的大小

全缓存大小：4096(4K)

#include <stdio.h>

int main(int argc, const char* argv[])
{
    FILE* fp;
    if ((fp = fopen("./hello.txt", "w+")) == NULL) {
        perror("fopen  error\n");
        return -1;
    }

    //必须先使用一下缓冲区，否则缓冲区的大小是0
    fputc('u',fp);
    //全缓存的大小是4096（4K）
    printf("file buffer size = %ld\n",
        fp->_IO_buf_end - fp->_IO_buf_base);


    fclose(fp);
    return 0;
}

行缓存大小：1k

#include <stdio.h>

int main(int argc, const char* argv[])
{
    int num;
    //标准输入大小验证的时候，必须先使用系统才分配大小，
    //否则大小就是0
    scanf("%d", &num);
    //行缓存（标准输入）大小是1024（1K）
    printf("stdin buffer size = %ld\n",
        stdin->_IO_buf_end - stdin->_IO_buf_base);

    //行缓存（标准输出）大小是1024（1K）
    printf("stdout buffer size = %ld\n",
        stdout->_IO_buf_end - stdout->_IO_buf_base);
    return 0;
}

不缓存大小：0

#include <stdio.h>

int main(int argc, const char* argv[])
{
    //使用一下标准出错
    fputc('t',stderr);

    //打印的大小是1，表示一次接收一个字符，并
    //将这个字符直接显示到终端上，所以认为这个
    //stderr缓冲区的大小是0
    printf("stderr buffer size = %ld\n",
        stderr->_IO_buf_end - stderr->_IO_buf_base);
    
    return 0;
}

1.3缓冲区的刷新时机

行缓存的刷新时机

#include <stdio.h>

int main(int argc, const char* argv[])
{
    // 1.行缓存遇到换行符的时候会刷新缓冲区
    //  printf("1111111111111111\n");
    //  while(1);

    // 2.当程序结束的时候会刷新行缓存
    //  printf("1111111111111111");

    // 3.当输入和输出发生切换的时候也会刷新行缓存
    // printf("1111111111111111");
    // int num;
    // scanf("%d",&num);
    // while(1);

    // 4.当文件指针被关闭的时候也会刷新缓冲区
    // printf("1111111111111111");
    // fclose(stdout);
    // while (1);

    // 5.当行缓存满的时候会刷新缓冲区
    // for(int i=0;i<=1024;i++){
    //     fputc('a',stdout);
    // }
    // while(1);

    // 6.使用fflush强制刷新缓冲区
    printf("1111111111111111");
    fflush(stdout);
    while (1);
    
    return 0;
}

全缓存的刷新时机

#include <stdio.h>

int main(int argc, const char* argv[])
{
    FILE* fp;
    if ((fp = fopen("./hello.txt", "w+")) == NULL) {
        perror("fopen  error\n");
        return -1;
    }

    // 1.全缓存遇到换行符的时候不会刷新缓冲区
    // fputc('y', fp);
    // fputc('\n', fp);
    // while (1);

    // 2.当程序结束的时候会刷新全缓存
    // fputc('y', fp);

    // 3.当输入和输出发生切换的时候也会刷新全缓存
    // fputc('O', fp);
    // fgetc(fp);
    // while(1);

    // 4.当文件指针被关闭的时候也会刷新全缓存
    // fputc('W', fp);
    // // fclose(fp);
    // while (1);

    // 5.当全缓存满的时候会刷新缓冲区
    // for(int i=0;i<=4096;i++){
    //     fputc('a',fp);
    // }
    // while(1);

    // 6.使用fflush强制刷新缓冲区
    fputc('Q', fp);
    fflush(fp);
    while (1);

    return 0;
}

2.fputs/fgets函数使用

2.1fputs/fgets函数接口介绍

char *fgets(char *s, int size, FILE *stream);
功能：从文件中读取字符串到s中（读取到EOF或者换行符的时候会停止，读取到size的时候会停）
//如果fgets读取到'\n'停止了，会将换行符保存在s中
//在s的buffer中紧接着数据的字符一定会有一个字符标志'\0'
参数：
    @s:存放读取到的字符串
    @size:读取的大小(最大size-1)
    @stream:文件指针
返回值：成功返回s,失败返回NULL
        
int fputs(const char *s, FILE *stream);
功能：将s中的数据写入到stream中
参数：
    @s:被写数据的首地址
    @stream:文件指针
返回值：成功返回大于0的数，失败返回EOF(-1)

2.2fgets的实例（stdin）

#include <stdio.h>
#include <string.h>

int main(int argc,const char * argv[])
{
    char buf[10] = {0};
    //从标准输入中将数据读取到buf中
    //最多读取9个字符
    fgets(buf,sizeof(buf),stdin);

    //将读取到的数据显示到终端上
    // printf("buf = %s\n",buf);


    //如果buf足够大，在读取到的数据中一定包含一个'\n'
    //一般会选择将'\n'处理掉
    // 12345'\n''\0'
    buf[strlen(buf)-1] = '\0';
    printf("buf = %s\n",buf);

    return 0;
}

2.3使用fgets统计一个文件的行号

char buf[10] = {0};

#include <head.h>
// /usr/include/

int main(int argc, const char* argv[])
{
    FILE* fp;
    int line = 0;
    char buf[10] = { 0 };
    // 1.校验参数
    if (argc != 2) {
        printf("input error,try again\n");
        printf("usage: ./a.out filename\n");
        return -1;
    }
    // 2.打开文件
    if ((fp = fopen(argv[1], "r")) == NULL)
        PRINT_ERR("fopen error");

#if 0
    // 3.读取文件内容，统计行号
    while(fgets(buf,sizeof(buf),fp)!=NULL){
        if(buf[strlen(buf)-1] == '\n')
            line++;
    }
    //4.输出line+1
    printf("line = %d\n",line+1);

#else
    // 3.读取文件内容，统计行号
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (strlen(buf) == sizeof(buf) - 1) {
            if (buf[strlen(buf) - 1] != '\n') {
                continue;
            }
        }
        line++;
    }

    if (strlen(buf) == sizeof(buf) - 1)
        line++;
    // 4.输出line+1
    printf("line = %d\n", line);
#endif
    //5.关闭文件
    fclose(fp);
    return 0;
}

2.4fputs使用实例(stderr/fp)

#include <head.h>

int main(int argc, const char* argv[])
{
    FILE* fp;
    int line = 0;
    char buf[10] = { 0 };
    // 1.校验参数
    if (argc != 2) {
        fputs("input error,try again\n", stderr);
        fputs("usage: ./a.out filename\n",stderr);
        return -1;
    }
    // 2.打开文件
    if ((fp = fopen(argv[1], "w")) == NULL)
        PRINT_ERR("fopen error");

    // 3.向文件中写
    fputs("hello\n", fp);
    fputs("world\n", fp);

    // 4.关闭文件
    fclose(fp);
    return 0;
}

2.5使用fputs和fgets实现文件的拷贝

#include <stdio.h>
void copy_file(FILE* sfp, FILE* dfp)
{
    char buf[128] = { 0 };

    while (fgets(buf, sizeof(buf), sfp) != NULL) {
        fputs(buf,dfp);
    }
}
int main(int argc, const char* argv[])
{
    // 1.校验参数
    if (argc != 3) {
        printf("input error,try again\n");
        printf("usage: ./a.out srcfile destfile\n");
        return -1;
    }
    // 2.打开文件
    FILE *sfp, *dfp;
    if ((sfp = fopen(argv[1], "r")) == NULL) {
        perror("fopen srcfile error\n");
        return -1;
    }
    if ((dfp = fopen(argv[2], "w")) == NULL) {
        perror("fopen destfile error\n");
        return -1;
    }
    // 3.拷贝
    copy_file(sfp, dfp);
    
    // 4.关闭文件
    fclose(sfp);
    fclose(dfp);
    return 0;
}

3.fread/fwrite函数的使用

3.1fread/fwrite函数介绍

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
功能：从文件中读取nmemb项，每一项的大小是size,将读取到的数据存储到ptr中。
参数
    @ptr:存储读取到数据的首地址
    @size:每一项的大小
 @nmemb:项目的个数
    @stream:文件指针
返回值:成功返回项目的个数，只要小于项目的个数就是失败
     fread读取的数据小于项目个数的时候可能是EOF也可能是失败了，
     需要工程师调用feof(fp)或者ferror(fp)来判断
    
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
功能：将ptr中的数据写入到文件中，写入nmemb项，每一项的大小是size
参数：
    @ptr:想要写的数据的首地址
 @size:每一项的大小
    @nmemb:项目的个数
 @stream:文件的指针
返回值：成返回写入项目的个数，小于想写的项目的个数的时候就是失败

3.2fwrite/fread函数使用实例(读写字符串)

fwrite.c

#include <head.h>

int main(int argc,const char * argv[])
{
    char buf[128] = {0};
    //从终端上输入任意字符到该程序中，
    //该程序将输入的字符串写入到hello.txt文件中

    //1.从终端向当前的程序读取数据
    printf("input > ");
    fgets(buf,sizeof(buf),stdin);
    buf[strlen(buf)-1] = '\0';

    //2.把buf的数据写入到文件中
    FILE *fp;
    if((fp = fopen("./hello.txt","w"))==NULL)
        PRINT_ERR("fopen hello.txt error");

    fwrite(buf,1,strlen(buf),fp);
    // fwrite(buf,strlen(buf),1,fp);

    //3.关闭文件
    fclose(fp);
    return 0;
}

fread.c

#include <head.h>

int main(int argc, const char* argv[])
{
    char buf[128] = {0};
    FILE* fp;
    if ((fp = fopen("./hello.txt", "r")) == NULL)
        PRINT_ERR("fopen hello.txt error");

    fread(buf,1,sizeof(buf),fp);

    printf("buf = %s\n",buf);

    fclose(fp);

    return 0;
}

3.3fwrite/fread函数使用实例(读写整数)

fwrite.c

#include <head.h>

int main(int argc, const char* argv[])
{    
 int num;
    printf("input > ");
    scanf("%d", &num);

    FILE* fp;
    if ((fp = fopen("./hello.txt", "w")) == NULL)
        PRINT_ERR("fopen hello.txt error");
 
    //将整数写入到hello.txt中，看到的是乱码，原因是文本编辑器
    //只失败字符，而1234这个整数没有字符对应，所以看到的就是乱码
    //但是按照同种方式读取出来，这个数据依然是没问题的
    fwrite(&num, sizeof(num), 1, fp);

    fclose(fp);

    return 0;
}

fread.c

#include <head.h>

int main(int argc, const char* argv[])
{    
	int num;
    FILE* fp;
    if ((fp = fopen("./hello.txt", "r")) == NULL)
        PRINT_ERR("fopen hello.txt error");

    fread(&num,sizeof(num),1,fp);

    printf("num = %d\n",num);

    fclose(fp);
    return 0;
}

3.4fwrite/fread函数使用实例(读写结构体)

fwrite.c

#include <head.h>

typedef struct {
    char name[20];
    int age;
} stu_t;

int main(int argc, const char* argv[])
{    
 stu_t stu = {
        "zhangsan",
        20,
    };
    FILE* fp;
    if ((fp = fopen("./hello.txt", "w")) == NULL)
        PRINT_ERR("fopen hello.txt error");

    fwrite(&stu, sizeof(stu), 1, fp);

    fclose(fp);

    return 0;
}

fread.c

#include <head.h>
typedef struct {
    char name[20];
    int age;
} stu_t;
int main(int argc, const char* argv[])
{
    stu_t stu;
    FILE* fp;
    if ((fp = fopen("./hello.txt", "r")) == NULL)
        PRINT_ERR("fopen hello.txt error");

    fread(&stu, sizeof(stu), 1, fp);

    printf("name = %s,age = %d\n", stu.name,stu.age);

    fclose(fp);
    return 0;
}

3.5使用fread/fwrite拷贝文件

#include <stdio.h>
void copy_file(FILE* sfp, FILE* dfp)
{
    char buf[128] = { 0 };
    int ret;
    //当读取到文件结尾的时候feof(sfp)返回真
    //如果读取的时候失败了ferror(sfp)也是真
    //只有两者同时为假的时候才能循环读写数据
    while (!(feof(sfp) || ferror(sfp))) {
        ret = fread(buf, 1, sizeof(buf), sfp);
        fwrite(buf, 1, ret, dfp);
    }
}
int main(int argc, const char* argv[])
{
    // 1.校验参数
    if (argc != 3) {
        printf("input error,try again\n");
        printf("usage: ./a.out srcfile destfile\n");
        return -1;
    }
    // 2.打开文件
    FILE *sfp, *dfp;
    if ((sfp = fopen(argv[1], "r")) == NULL) {
        perror("fopen srcfile error\n");
        return -1;
    }
    if ((dfp = fopen(argv[2], "w")) == NULL) {
        perror("fopen destfile error\n");
        return -1;
    }
    // 3.拷贝
    copy_file(sfp, dfp);

    // 4.关闭文件
    fclose(sfp);
    fclose(dfp);
    return 0;
}

4.sprintf/snprintf/fprintf函数的使用

4.1sprintf/snprintf/fprintf函数介绍

int sprintf(char *str, const char *format, ...);
功能：通过格式化控制函数将字符串保存到str对应的内存中了
参数：
    @str:存储格式化后字符串的首地址
    @format,...:根printf的参数完全相同
返回值：成功返回格式化的字符的个数，失败返回小于0的数
        
int snprintf(char *str, size_t size, const char *format, ...);
功能：通过格式化控制函数将字符串保存到str对应的内存中了
参数：
    @str:存储格式化后字符串的首地址
    @size:格式化字符的个数（最多格式化size-1,最后一个是结束符'\0'）
    @format,...:根printf的参数完全相同
返回值：成功返回格式化的字符的个数，失败返回小于0的数

int fprintf(FILE *stream, const char *format, ...);
功能：通过格式化控制函数将字符串保存到文件
参数：
    @stream:文件指针
 @format...：根printf的参数完全相同
返回值：成功返回格式化的字符的个数，失败返回小于0的数

4.2sprintf函数实例

#include <head.h>

typedef struct {
    char name[20];
    int age;
} stu_t;

int main(int argc, const char* argv[])
{
    char buf[128] = {0};
    stu_t stu = {
        "zhangsan",
        20,
    };
    FILE* fp;
    if ((fp = fopen("./hello.txt", "w")) == NULL)
        PRINT_ERR("fopen hello.txt error");

    //将name和age转换成字符串存到buf中
    //在使用sprintf的时候一定要保证buf比格式化的字符串成员多
    //否则就会越界访问，程序崩溃
    sprintf(buf,"%s,%d",stu.name,stu.age);
    fwrite(buf,1, strlen(buf), fp);

    fclose(fp);

    return 0;
}

练习：

向程序输入一个文件名（任意）hello.txt,在程序中创建一个以new_hello.txt命名的空文件

#include <head.h>

int main(int argc, const char* argv[])
{
    char filename[128] = {0};
    // 1.校验参数
    if (argc != 2) {
        printf("input error,try again\n");
        printf("usage: ./a.out filename\n");
        return -1;
    }
    //2.拼接新的名字
    sprintf(filename,"new_%s",argv[1]);
    //3.创建文件
    FILE *fp;
    if((fp = fopen(filename,"w"))==NULL)
        PRINT_ERR("fopen file error");

    //4.关闭文件
    fclose(fp);
    return 0;
}

4.3snprintf函数实例

#include <head.h>

typedef struct {
    char name[20];
    int age;
} stu_t;

int main(int argc, const char* argv[])
{
    char buf[8] = {0};
    stu_t stu = {
        "zhangsan",
        20,
    };
    FILE* fp;
    if ((fp = fopen("./hello.txt", "w")) == NULL)
        PRINT_ERR("fopen hello.txt error");

    //在格式化字符串的时候，字符串的长度超过了sizeof(buf)
    //但是最多格式化sizeof(buf)-1字符，剩余没有被格式化的字符
    //被忽略掉，虽然编译的时候编译器会发出警告，但是程序执行的
    //时候不会崩溃。所以snprintf要比sprintf更为安全。
    snprintf(buf,sizeof(buf),"%s,%d",stu.name,stu.age);
    fwrite(buf,1, strlen(buf), fp);

    fclose(fp);

    return 0;
}

练习：请将系统的时间写入到time.txt文件中，每秒写一次。

#include <time.h>

time_t time(time_t *tloc);
功能：获取系统的当前时间（单位是秒，从1970-01-01 00:00:00-2022-08-31 15:55:00）
参数：
    @tloc:NULL （通过返回值接收秒钟数）
返回值：成功返回的是秒钟数，失败返回-1置位错误码

struct tm *localtime(const time_t *timep);
功能：将秒钟数转换为struct tm的结构体
参数：
    @timep：秒钟变量的地址
返回值：成功返回tm结构体指针，失败返回NULL,置位错误
   struct tm {
       int tm_sec;    /* Seconds (0-60) */
       int tm_min;    /* Minutes (0-59) */
       int tm_hour;   /* Hours (0-23) */
       int tm_mday;   /* Day of the month (1-31) */
       int tm_mon;    /* Month (0-11)  */ //+1
       int tm_year;   /* Year - 1900  */  //+1900
       int tm_wday;   /* Day of the week (0-6, Sunday = 0) */ 
       int tm_yday;   /* Day in the year (0-365, 1 Jan = 0) */
       int tm_isdst;  /*夏令时*/
   };

#include <head.h>
#include <time.h>

int main(int argc,const char * argv[])
{
    time_t ts;
    struct tm *tm;
    if((ts=time(NULL))==(time_t)-1)
        PRINT_ERR("get time second error");

    if((tm = localtime(&ts))==NULL)
        PRINT_ERR("change time error");

    printf("%d-%02d-%02d %02d:%02d:%02d\n",tm->tm_year+1900,
    tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec);
    return 0;
}

4.4fprintf函数实例

#include <head.h>

int main(int argc,const char * argv[])
{
    FILE *fp;
    char buf[] = "i am learning io course";
    int t=45378;

    if((fp = fopen("hello.txt","w"))==NULL)
        PRINT_ERR("fopen error");

    //将字符串写入到hello.txt文件中
    fprintf(fp,"%s,%d\n",buf,t);   
    //将字符串写入到标准输出中 
    fprintf(stdout,"%s,%d\n",buf,t);  
    //将字符串写入到标准出错中 
    fprintf(stderr,"%s,%d\n",buf,t);   
    fclose(fp);
    return 0;
}

5.作业

将当前的时间写入到tim.txt的文件中，如果ctrl+c退出之后，在再次执行支持"断点续写"

1.2022-03-25 19:10:20

2.2022-03-25 19:10:21

3.2022-03-25 19:10:22

//按下ctrl+c停止，再次执行程序

4.2022-03-25 20:00:00

5.2022-03-25 20:00:01

#include <head.h>
#include <time.h>
int GetFileLine(FILE* fp)
{
    int line = 1;
    char buf[128] = { 0 };
    while (fgets(buf, sizeof(buf), fp) != NULL) {
        if (buf[strlen(buf) - 1] == '\n')
            line++;
    }
    return line;
}
int main(int argc, const char* argv[])
{
    time_t ts, ots;
    struct tm* tm;
    int line = 0;
    FILE* fp;
    // 1.打开文件
    if ((fp = fopen("./time.txt", "a+")) == NULL)
        PRINT_ERR("fopen error");
    // 2.读取文件的行号
    line = GetFileLine(fp);

    // 3.循环向文件中显示时间
    ts = ots = 0;
    while (1) { // 2022-9-1 09:13:50
        if ((ts = time(NULL)) == (time_t)-1)
            PRINT_ERR("get time second error");
        if (ts != ots) {
            ots = ts;
            if ((tm = localtime(&ts)) == NULL)
                PRINT_ERR("change time error");

            fprintf(fp, "%4d.%d-%02d-%02d %02d:%02d:%02d\n", line++, tm->tm_year + 1900,
                tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
            fflush(fp);
        }
    }

    fclose(fp);
    return 0;
}

#include <head.h>
#include <time.h>

int main(int argc, const char* argv[])
{
    time_t ts, ots;
    struct tm* tm;

    ts = ots = 0;
    while (1) { //2022-9-1 09:13:50
        if ((ts = time(NULL)) == (time_t)-1)
            PRINT_ERR("get time second error");
        if (ts != ots) {
            ots = ts;
            if ((tm = localtime(&ts)) == NULL)
                PRINT_ERR("change time error");
   //在终端显示时间，在一个位置一直刷新显示
            printf("%d-%02d-%02d %02d:%02d:%02d\r", tm->tm_year + 1900,
                tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
            fflush(stdout);
        }
    }
    return 0;
}
MYK0030
关注
标准IO——缓冲区实验
qq_44705952的博客
11-23 422
在进行一些需要频繁操作访问文件的操作时，像访问磁盘文件。由于向磁盘驱动器传入数据或者从磁盘驱动器传出数据都是相对较慢的操作。因此，为了获得更好的性能，我们通常采用在文件读写过程中加入缓冲，因为无门对缓冲区的读写几乎是不花什么时间的，而且每次“大块”的移动也会比单一字节的移动要快很多。换从操作都是在系统后台自动进行的，如果极少数情况下需要我么主动对缓冲进行操作的话，可以使用以下几个函数fflush函数、setbuf函数和setvbuf函数。
关于sprintf 和 snprintf的自拷贝
weixin_34212762的博客
11-23 294
朋友出了这样一道题：char buf[100];memset(buf, 0, 100);strcpy(buf, "hello");sprintf(buf, "%s world\n", buf);printf("%s\n", buf);结果是什么？   在不同的编译器上，结果不同，有的显示" world"，有的显示"hello world"，我们发现，对于这种自拷贝的问题，编译器可以有不同的策略...
snprintf拷贝字符串
weixin_34255793的博客
10-31 559
函数原型：int snprintf(char *dest, size_t n, const char *fmt, ...); 函数说明: 最多从源串中拷贝n－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为n的话，将不会溢出。 函数返回值: 若成功则返回存入数组的字符数，若编码出错则返回负值。 #include <stdio.h> #include...
行缓存和全缓存的缓冲刷新机制
weixin_46082024的博客
06-29 512
行缓存缓冲区刷新机制 全缓存刷新机制
strcpy,sprintf,memcpy的区别
Linux Operating System 的专栏
08-09 1291
 strcpy 函数操作的对象是 字符串，完成 从 源字符串 到 目的字符串 的 拷贝 功能。snprintf 函数操作的对象 不限于字符串：虽然目的对象是字符串，但是源对象可以是字符串、也可以是任意基本类型的数据。这个函数主要用来实现 （字符串或基本数据类型）向 字符串 的转换 功能。如果源对象是字符串，并且指定 %s 格式符，也可实现字符串拷贝功能。memcpy 函数顾名思义就是 内存拷贝，实
RAPIDIO嵌入式系统互连_rapidio中文协议_rapidio嵌入式_
10-02
《RAPIDIO嵌入式系统互连》是深入理解 RapidIO 协议的重要参考资料，尤其对初学者来说，中文版的翻译提供了更为便捷的理解途径。RapidIO 是一种高性能、低延迟的串行互连技术，最初设计用于满足通信设备和嵌入式系统...
rapidIO嵌入式系统互连_rapidio_rapidIO嵌入式系统互连_rapidio嵌入式_嵌入式_
09-28
《RapidIO嵌入式系统互连》是关于嵌入式系统中的一种高速互连技术的探讨，主要聚焦于RapidIO技术及其在系统设计中的应用。RapidIO是一种开放标准的、基于串行通信协议的互连技术，最初由RapidIO Trade Association...
嵌入式IO端口PPT教案.pptx
10-04
嵌入式系统中的I/O端口是硬件与软件交互的关键接口，用于控制设备输入和输出。在本PPT教案中，主要介绍了S3C2440处理器的I/O端口特性及其编程方法。 S3C2440是一款广泛应用的嵌入式微处理器，它拥有丰富的通用I/O...
RapidIO 嵌入式系统互连 [美] Sam Fuller 著
08-14
《RapidIO 嵌入式系统互连》是由Sam Fuller撰写的一本深入解析RapidIO技术的专业书籍，属于国外电子与通信教材系列。RapidIO是一种高性能、低延迟的串行互连协议，主要用于构建复杂的嵌入式系统，尤其在通信、网络...
C++字符串复制/拷贝
热门推荐
u012884015的博客
08-25 1万+
snprintf sprintf不能检查目标字符串的长度，可能造成众多安全问题, snprintf是的sprintf的安全版本，他的特点是安全，不管怎么着，它都能保证结果串str以\0结尾，哪怕dst_size不够大，它都能做好截断，同时在末尾添加上\0。 int snprintf(char *str, size_t size, const char *format, ...); 函数说明: 最多从源串中拷贝size－1个字符到目标串中，然后再在后面加一个0。所以如果目标串的大小为size的话，将不会溢出
linux 性能杀手 snprintf,字符串拷贝函数memcpy和strncpy以及snprintf 的性能比较
weixin_29032489的博客
05-13 716
问题：函数memcpy(dest, src, sizeof(dest))、strncpy(dest, src, sizeof(dest))和snprintf(dest, sizeof(dest), "%s", src)都可以将src字符串中的内容拷贝到dest字符串中。哪一种方式效率最高呢？就是说，哪种方式性能最好呢？解决办法：1. 建立三个文件test_memcpy.c，test_strncpy...
标准IO及缓存
m0_72010841的博客
02-04 1083
标准IO及相关函数
c语言缓存大小 fwrite,fread和fwrite函数，C语言fread和fwrite函数详解
weixin_35657099的博客
05-17 1373
对文件格式化读写函数 fprintf 与 fscanf 而言，尽管它可以从磁盘文件中读写任何类型的文件，即读写的文件类型可以是文本文件、二进制文件，也可以是其他形式的文件。但是，对二进制文件的读写来说，考虑到文件的读写效率等原因，还是建议尽量使用 fread 和 fwrite 函数进行读写操作。fread 与 fwrite 函数的原型如下面的代码所示：size_t fread(void *buf,...
c语言缓存大小 fwrite,c - Fwrite不在文件中写入数据。 C语言 - 堆栈内存溢出
weixin_33253331的博客
05-17 485
我有一个以前用某种结构写入的二进制文件，但是当我尝试使用函数fwrite的函数write_disc_eof向该文件中输入一些数据时，不要在文件上写入数据。如果我将fopen模式更改为wb或wb + fwrite，请成功在文件上写入数据，但我要追加，并且fopen上的“ rb +”，“ ab”或“ ab +”都不要让fwrite插入数据。 在任何情况下， fwrite都会成功返回，但数据不会仍然显...
IO接口中的fread/fwrite/fflush分析
m0_70418130的博客
10-09 970
linux底层操作；内核调用， 涉及到进程上下文的切换，即用户态到核心态的转换，这是个比较消耗性能的操作。：c语言标准规定的io流操作，建立在read/write/fsync之上在用户层，又增加了一层缓冲机制，用于减少内核调用次数，但是增加了一次内存拷贝。可以将fread,fwrite是一种批量写入，而read,write是单次写入的形式来理解。对于输入设备，调用fsync/fflush将清空相应的缓冲区，其内数据将被丢弃;
IO进程-IO
最新发布
zhong_hua210231的博客
02-16 126
IO进程初学者的笔记
fopen的默认缓冲大小和setvbuf 用法
weixin_30919571的博客
07-18 214
《unix环境高级编程》是这么说的： 标准IO流操作读写普通文件是使用全缓冲的，默认缓冲区长度是该文件系统优先选用的IO长度（从stat结构得到的st_blksize值） //读取st_blksize的例子： int main(int argc, char* argv[]){ if(argc!=2) { printf("2 argment\n"); r...
嵌入式系统网络芯片与IO接口解析
I/O接口和总线的工作原理中，讲解了常见的接口类型，如I2C、I2S、CAN和以太网总线，以及并行接口（如RS-232）、串行接口（如IEEE1394、USB）和无线接口（如红外线、蓝牙、IEEE802.11、GPRS、CDMA）。这些接口提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值