读写_读写锁 - CSDN
精华内容
参与话题
  • C语言文件操作之----文件的读写

    万次阅读 2007-10-21 20:05:00
    针对文本文件和二进制文件的不同性质,对文本文件来说,可按字符读写或按字符串读写;对二进制文件来说,可进行成块的读写或格式化的读写。1. 读写字符 C提供fgetc和fputc函数对文本文件进行字符的读写,其函数的...
    当文件按指定的工作方式打开以后,就可以执行对文件的读和写。下面按文件的性质分类进行操作。针对文本文件和二进制文件的不同性质,对文本文件来说,可按字符读写或按字符串读写;对二进制文件来说,可进行成块的读写或格式化的读写。
    1. 读写字符
        C提供fgetc和fputc函数对文本文件进行字符的读写,其函数的原型存于stdio.h头文件中,格式为:
        int fgetc(FILE *stream)
        fgetc( )函数从输入流的当前位置返回一个字符,并将文件指针指示器移到下一个字符处,如果已到文件尾,函数返回EOF,此时表示本次操作结束,若读写文件完成,则应关闭文件。
    int fputc(int ch,FILE *stream)
    fputc()函数完成将字符c h的值写入所指定的流文件的当前位置处,并将文件指针后移一位。fputc()函数的返回值是所写入字符的值,出错时返回EOF。

    [例8-2] 将存放于磁盘的指定文本文件按读写字符方式逐个地从文件读出,然后再将其显示到屏幕上。采用带参数的main( ),指定的磁盘文件名由命令行方式通过键盘给定。
    #i nclude<stdio.h>
    main(argc,argv)
    int argc;
    char *argv[];
    {
        char ch;
        FILE *fp;
        int i;
        if((fp=fopen(argv[1],"r"))==NULL) /* 打开一个由argv[1]所指的文件*/
        {
            printf("not open");
            exit(0);
        }
        while ((ch=fgetc(fp))!=EOF) /* 从文件读一字符,显示到屏幕*/
            putchar(ch);
        fclose(fp);
    }
        程序是一带参数的main( )函数,要求以命令行方式运行,其参数argc是用于记录输入参数的个数, argv是指针数组,用于存放输入参数的字符串,串的个数由argc描述。假设我们指定读取的文件名为L8-2.c,并且列表文件内容就是源程序。经过编 译和连接生成可执行的文件L8-2.exe。运行程序l8-2.exe,输入的命令行方式为:
    c:/tc>l8-2 L8-2.c
        上述程序以命令行方式运行,其输入参数字符串有两个,即argv[0]="c:/tc>l8-2"、argv[1]=" L8-2.c ",argc = 2。故打开的文件是L8-2.c 。程序中对fgetc( )函数的返回值不断进行测试,若读到文件尾部或读文件出错,都将返回C的整型常量EOF,其值为非零有效整数。程序的运行输出为源程序本身:
    c:/tc>l8-2 L8-2.c
    #i nclude <stdio.h>
    main( argc,argv)
    int argc;
    char *argv[];
    {
        char ch;
        FILE *fp;
        int i;
        if((fp=fopen(argv[1],"r"))==NULL) /* 打开一个由argv[1] 所指的文件*/
        {
            printf("not open");
            exit(0);
        }
        while ((ch=fgetc(fp))!=EOF) /* 从文件读一字符,显示到屏幕*/
            putchar(ch);
        fclose(fp);
    }

    [例8-3] 从键盘输入字符,存到磁盘文件test.txt中:
    #i nclude <stdio.h>
    main( )
    {
        FILE fp; / *定义文件变量指针* /
        char ch;
        if((fp=fopen("test.txt","w"))==NULL)  /*以只写方式打开文件*/
        {
            printf("cannot open file!/n");
            exit(0);
        }
        while ((ch=fgetchar())!='/n') /*只要输入字符非回车符* /
            fputc(ch,fp) /*写入文件一个字符*/
        fclose(fp);
    }
        程序通过从键盘输入一以回车结束的字符串,写入指定的流文件test.txt,文件以文本只写方式打开,所以流文件具有可读性,能支持各种字符处理工具访问。简单地说,我们可以通过DOS提供的type命令来列表显示文件内容。
    运行程序:
    I love china!
    在DOS操作系统环境下,利用type 命令显示test.txt文件如下:
    c:/tc> type test.txt
    I love china!

    2. 读写字符串
        C提供读写字符串的函数原型在stdio.h头文件中,其函数形式为:
        Char *fgets(char *str,int num,FILE *stream)
        fgets() 函数从流文件stream中读取至多num-1个字符,并把它们放入str指向的字符数组中。读取字符直到遇见回车符或E O F(文件结束符)为止,或读入了所限定的字符数。
        int fputs(char *str,FILE *stream)
        fputs( )函数将str指向的字符串写入流文件。操作成功时,函数返回0值,失败返回非零值。

    [例8-4] 向磁盘写入字符串,并写入文本文件test.txt:
    #i nclude<stdio.h>
    #i nclude<string.h>
    main( )
    {
        FILE *fp;
        char str[128];
        if ((fp=fopen("test.txt","w"))==NULL) /*打开只写的文本文件*/
        {
            printf("cannot open file!");
            exit(0);
        }
        while((strlen(gets(str)))!=0)
        { /*若串长度为零,则结束*/
            fputs(str,fp); /*写入串*/
            fputs("/n",fp); /*写入回车符*/
        }
        fclose(fp); /*关文件*/
    }
        运行该程序,从键盘输入长度不超过1 2 7个字符的字符串,写入文件。如串长为0,即空串,程序结束。
    输入:Hello!
    How do you do
    Good-bye!

    运行结束后,我们利用dos的type命令列表文件:
    c:/tc>type test.txt
    Hello!
    How do you do
    Good-bye!
    这里所输入的空串,实际为一单独的回车符,其原因是gets函数判断串的结束是以回车作标志的。

    [例8-5] 从一个文本文件test1.txt中读出字符串,再写入令一个文件test2.txt。
    #i nclude<stdio.h>
    #i nclude<string.h>
    main( )
    {
        FILE *fp1,*fp2;
        char str[128];
        if ((fp1=fopen("test1.txt","r"))==NULL)
        { / * 以只读方式打开文件1 */
            printf("cannot open file/n");
            exit(0);
        }
        if((fp2=fopen("test2.txt","w"))==NULL)
        { /*以只写方式打开文件2 */
            printf("cannot open file/n");
            exit(0);
        }
        while ((strlen(fgets(str,128,fp1)))>0)
        /*从文件中读回的字符串长度大于0 */
        {
            fputs(str,fp2 ); /* 从文件1读字符串并写入文件2 */
            printf("%s",str); /*在屏幕显示*/
        }
        fclose(fp1);
        fclose(fp2);
    }
        程序共操作两个文件,需定义两个文件变量指针,因此在操作文件以前,应将两个文件以需要的工作方式同时打开(不分先后),读写完成后,再关闭文件。设计过 程是按写入文件的同时显示在屏幕上,故程序运行结束后,应看到增加了与原文件相同的文本文件并显示文件内容在屏幕上。

    3. 格式化的读写
        前面的程序设计中,我们介绍过利用scanf( )和printf( )函数从键盘格式化输入及在显示器上进行格式化输出。对文件的格式化读写就是在上述函数的前面加一个字母f成为fscanf( )和fprintf( )。其函数调用方式:
        int fscanf(FILE *stream,char *format,arg_list)
        int fprintf(FILE *stream,char *format,arg_list)
        其中,stream为流文件指针,其余两个参数与scanf( )和printf( )用法完全相同。

    [例8-6] 将一些格式化的数据写入文本文件,再从该文件中以格式化方法读出显示到屏
    幕上,其格式化数据是两个学生记录,包括姓名、学号、两科成绩。
    #i nclude<stdio.h>
    main( )
    {
        FILE *fp;
        int i;
        struct stu{ /*定义结构体类型*/
            char name[15];
            char num[6];
            float score[2];
        }student; /*说明结构体变量*/
        if((fp=fopen("test1.txt","w"))==NULL)
        { /*以文本只写方式打开文件*/
            printf("cannot open file");
            exit(0);
        }
        printf("input data:/n");
        for( i=0;i<2;i++)
        {
            scanf("%s %s %f %f",student.name,student.num,&student.score[0],
            &student.score[1]); /*从键盘输入*/
            fprintf(fp,"%s %s %7.2f %7.2f/n",student.name,student.num,
            student.score[0],student.score[1]); /* 写入文件*/
        }
        fclose(fp); /*关闭文件*/
        if((fp=fopen("test.txt","r"))==NULL)
        { /*以文本只读方式重新打开文件*/
            printf("cannot open file");
            exit(0);
        }
        printf("output from file:/n");
        while (fscanf(fp,"%s %s %f %f/n",student.name,student.num,&student.score[0],student.score[1])!=EOF)
        / *从文件读入* /
            printf("%s %s %7.2f %7.2f/n",student.name,student.num,
        student.score[0],student.score[1]); /* 显示到屏幕*/
        fclose(fp); /*关闭文件*/
    }
        程序设计一个文件变量指针,两次以不同方式打开同一文件,写入和读出格式化数据,有一点很重要,那就是用什么格式写入文件,就一定用什么格式从文件读,否则,读出的数据与格式控制符不一致,就造成数据出错。上述程序运行如下:
    input data:
    xiaowan j001 87.5 98.4
    xiaoli j002 99.5 89.6
    output from file:
    xiaowan j001 87.50 98.40
    xiaoli j002 99.50 89.60

    列表文件的内容显示为:
    c:/>type test.txt
    xiaowan j001 87.50 98.40
    xiaoli j002 99.50 89.60
        此程序所访问的文件也可以定为二进制文件,若打开文件的方式为:
    if ((fp=fopen("test1.txt","wb"))==NULL)
    { / * 以二进制只写方式打开文件* /
        printf("cannot open file");
        exit(0);
    }
    其效果完全相同。

    4. 成块读写
       
    前面介绍的几种读写文件的方法,对其复杂的数据类型无法以整体形式向文件写入或从文件读出。C语言提供成块的读写方式来操作文件,使其数组或结构体等类型可以进行一次性读写。成块读写文件函数的调用形式为:
        int fread(void *buf,int size,int count,FILE *stream)
        int fwrite(void *buf,int size,int count,FILE *stream)
        fread()函数从stream 指向的流文件读取count (字段数)个字段,每个字段为size(字段长度)个字符长,并把它们放到b u f(缓冲区)指向的字符数组中。
        fread()函数返回实际已读取的字段数。若函数调用时要求读取的字段数超过文件存放的字段数,则出错或已到文件尾,实际在操作时应注意检测。
        fwrite( )函数从buf(缓冲区)指向的字符数组中,把count(字段数)个字段写到stream所指向的流中,每个字段为size个字符长,函数操作成功时返回所写字段数。
        关于成块的文件读写,在创建文件时只能以二进制文件格式创建。

    [例8-7] 向磁盘写入格式化数据,再从该文件读出显示到屏幕。
    #i nclude "stdio.h"
    #i nclude "stdlib.h"
    main( )
    {
        FILE *fp1;
        int i;
        struct stu{ / *定义结构体*/
            char name[15];
            char num[6];
            float score[2];
        }student;
        if((fp1=fopen("test.txt","wb"))==NULL)
        { /*以二进制只写方式打开文件* /
            printf("cannot open file");
            exit(0);
        }
        printf("input data:/n");
        for( i=0;i<2;i++) 
        {
            scanf("%s %s %f %f",student.name,student.num,&student.score[0],&student.score[1]); /* 输入一记录*/
            fwrite(&student,sizeof(student),1,fp1); /* 成块写入文件*/
        }
        fclose(fp1);
        if((fp1=fopen("test.txt","rb"))==NULL)
        { /*重新以二进制只写打开文件*/
            printf("cannot open file");
            exit(0);
        }
        printf("output from file:/n");
        for (i=0;i<2;i++)
        {
        fread(&student,sizeof(student),1,fp1); /* 从文件成块读*/
        printf("%s %s %7.2f %7.2f/n",student.name,student.num,student.score[0],student.score[1]); /* 显示到屏幕*/
        }
        fclose(fp1);
    }
    运行程序:
    input data:
    xiaowan j001 87.5 98.4
    xiaoli j002 99.5 89.6
    output from file:
    xiaowan j001 87.50 98.40
    xiaoli j002 99.50 89.60
        通常,对于输入数据的格式较为复杂的话,我们可采取将各种格式的数据当做字符串输入,然后将字符串转换为所需的格式。C提供函数:
        int atoi(char *ptr)
        float atof(char *ptr)
        long int atol(char *ptr)
        它们分别将字符串转换为整型、实型和长整型。使用时请将其包含的头文件math.h或stdlib.h写在程序的前面。
    展开全文
  • 用fread()和fwrite()读写文件

    千次阅读 2017-11-29 10:08:29
    ANSI C文件系统提供fread()和fwrite()两个函数,用于读/写长于一字节的数据类型。这两个函数允许读/写各种类型的数据块。它们的原型是: size_t fread(void *buffer,size_t num_bytes,size_t count,FILE *fp);...

          ANSI C文件系统提供fread()和fwrite()两个函数,用于读/写长于一字节的数据类型。这两个函数允许读/写各种类型的数据块。它们的原型是:

    size_t fread(void *buffer,size_t num_bytes,size_t count,FILE *fp);
    size_t fwrite(const void *buffer,size_t num_bytes,size_t count,FILE *fp);
          对fread()而言,buffer是接收读入数据的内存区的指针。

          对fwrite()而言,buffer是写入到那个文件的信息的指针。

          count的值确定读/写多少项,每项长度等于num_bytes。

          fp是指向事先打开的流的指针。

          正常情况下,fread()返回读入的项数,fwrite()返回写出的项数。

          只要文件按二进制打开,fread()和fwrite()就可以读/写各类信息。以下程序先向文件写double,int和long型数据,然后再读回。

    //向磁盘文件写入一些非字符型的数据,并且再将其读回到内存
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void)
    {
      FILE *fp;
      double d1 = 12.23,d2;
      int i1 = 101,i2;
      long l1 = 123023L,l2;
    
      if((fp=fopen("test", "wb+"))==NULL) {
        printf("Cannot open file.\n");
        exit(1);
      }
    
      //将3个值写入到文件中
      fwrite(&d1, sizeof(double), 1, fp);
      fwrite(&i1, sizeof(int), 1, fp);
      fwrite(&l1, sizeof(long), 1, fp);
    
      //重置到文件的开始处
      rewind(fp);
    
      //将3个值从文件中读出
      fread(&d2, sizeof(double), 1, fp);
      fread(&i2, sizeof(int), 1, fp);
      fread(&l2, sizeof(long), 1, fp);
    
      printf("%f %d %ld", d, i, l);
    
      fclose(fp);
    
      return 0;
    }

    展开全文
  • C语言-文件读写操作

    万次阅读 多人点赞 2019-01-21 19:12:23
    文本模式 //r 只读 //w 删除原有内容,重写入 文件不存在,还可以创建文件 //a 在原有内容后接着写 文件不存在,还可以创建文件 //r+ 可读可写 删除原有内容,重写入 //w+ //a+ //读取文件01.txt ...

    文本模式
    //r 只读
    //w 删除原有内容,重写入 文件不存在,还可以创建文件
    //a 在原有内容后接着写 文件不存在,还可以创建文件
    //r+ 可读可写 删除原有内容,重写入
    //w+
    //a+

    //读取文件01.txt
    FILE* pFile = fopen("01.txt", "r");
    

    二进制模式
    //rb,wb,ab

    //读取文件01.txt
    FILE* pFile = fopen("01.txt", "rb");
    

    写入文件,fwrite

    	FILE* pFile = fopen("01.txt", "w");
    	char* str = "C语言";
    	//fwrite(str, sizeof(char), strlen(str)+1, pFile);
    	
    	//fwrite的返回值,0写入失败 , 成功返回字符个数*字符大小
    	int a = fwrite(str, sizeof(char), strlen(str), pFile);
    	fclose(pFile);//关闭文件并保存
    

    :FILE* pFile = fopen(“01.txt”, “w”);//会将文件内容清空
    当要读文件时,不可以w,会清空文件内容

    读取文件,fread
    //读多个字符

    //读文件,r或a  不可以w,会清空文件内容
    	FILE* pFile = fopen("03.txt", "r");
    	char str[20] = { 0 };//用于存储文件中读取出的内容,要记住设置默认为\0
    	
    	//fread 返回值  每次读取字符后,整体长度变小
    	//文件中没有字符,返回0
    	//文件中有字符,且读取字符个数无论是否大于文件中总的字符个数,都返回读取字符个数
    	
    	int n = fread(str, sizeof(char), 2, pFile);//文件中的内容存储的字符数组str中,2表示每次读取文件的字符个数
    

    读取文件,fread
    //文件所有内容

    	FILE* pFile = fopen("03.txt", "r");
    	char str[20] = { 0 };//用于存储文件中读取出的内容,要记住设置默认为\0
    	int a;
    	while ( a = fread(str, sizeof(char), 2, pFile) )//文件内容为空时,a = 0
    	{
    	printf("%s", str);
    	}
    	fclose(pFile);
    

    文件内容为:
    在这里插入图片描述
    结果如下:
    在这里插入图片描述
    明显出现错误,我们是2个字符的读取,最后剩下一个字符了,只更新了一个,str[1]还是上一次循环的值,解决方法,在循环后加上这两句

    	str[0] = '\0';
    	str[1] = '\0';
    

    最后结果为:
    在这里插入图片描述
    文本模式和二进制模式行结尾的不同

    	FILE* pFile = fopen("04.txt", "rb");
    	char str[20] = { 0 };
    	//行结尾的不同
    	//文本模式读出一个字符\n
    	//二进制模式读出两个字符\r\n
    
    	while (!feof(pFile))//判断文件是否到结尾了  到结尾返回1,没到结尾返回0
    	{
    		int a = fread(str, sizeof(char), 20, pFile);
    		printf(str);
    		str[0] = 0;
    		str[1] = 0;
    	}
    
    	fclose(pFile);
    

    结构体写入文件

    	struct node
    	{
    		int num;
    		char name[15];
    		double height;
    		int age;
    	};
    	int main(void)
    	{
    		//结构体写入文件
    		struct node n = { 123, "jkl", 178.2, 22 };
    		//printf("%d\t%s\t%lf\t%d", n.num, n.name, n.height, n.age);
    	
    		FILE* pFile = fopen("05.txt", "r");
    	
    		//fwrite(&n, sizeof(n), 1, pFile);
    	
    		struct node n2;
    		fread(&n2, sizeof(n2), 1, pFile);
    		
    		printf("%d\t%s\t%lf\t%d", n2.num, n2.name, n2.height, n2.age);
    	
    		fclose(pFile);
    	}
    

    fgets读取文件一行和fputs写入文件一行

    	//fputs写入文件一行
    	FILE* pFile = fopen("06.txt", "w");
    	fputs("Hello\n", pFile);
    	fputs("World", pFile);
    
    	fclose(pFile);
    
    
    	//fgets读取文件一行
    	FILE* pFile2 = fopen("06.txt", "r");
    	char str[10] = { 0 };
    	fgets(str, 10, pFile2);
    	fgets(str, 10, pFile2);
    
    	fclose(pFile2);
    

    fprintffscanf
    //按照某种格式写入文件,读取时也按照某种格式

    	FILE* pfile = fopen("07.txt", "r");
    	//按照某种格式写入文件,读取时也按照某种格式
    	//fprintf(pfile, "%d %s %lf", 23, "jk", 8.42);
    	int n = 0;
    	char str[20] = { 0 };
    	double d = 0.0;
    	fscanf(pfile, "%d %s %lf", &n, &str, &d);
    
    	fclose(pfile);
    
    展开全文
  • 读写Eeprom

    千次阅读 2017-12-29 17:06:11
    使用I2c协议读写Eeprom的例子 Eeprom是一种可擦除反复编程的存储器,掉电也可以保存里面的数据不会丢失,可多次循环编程利用。接下来我们就是要用I2c协议读写Eeprom了。 我们先看一下Eeprom读写时讯,同样在最后我...

    使用I2c协议读写Eeprom的例子

    Eeprom是一种可擦除反复编程的存储器,掉电也可以保存里面的数据不会丢失,可多次循环编程利用。接下来我们就是要用I2c协议读写Eeprom了。

    我们先看一下Eeprom读写时讯,同样在最后我会放出我们读写完Eeprom后,逻辑分析仪出现的结果然后一一分析是为什么.

    首先根据I2c配置初始化使能引脚、时钟。里面还包括写一个字节。代码如下。PS(调用的i2c.WriteByte()函数实现过程参考我之前发的I2c库函数里面有具体代码)

    ///Initializes all necessary hardware
    void I2cEeprom::Initialize(uint8_t channel)
    {	
    	i2c.Initialize(channel);
    
    	//The parameter inside the function call can be 100 400 500.
    	//Corresponding to the general mode(100), fast mode(400), fast plus mode(500).
    	i2c.I2cClockSpeed(100);
    	ConfigPins();
    }
    
    void I2cEeprom::ConfigPins()
    {
    	I2c::I2cPinConfig pinConfig;
    	pinConfig.sclPin = 8;
    	pinConfig.sclAltNum = 4;
    	pinConfig.sclCh = Gpio::_ChB;
    									
    	pinConfig.sdaPin = 9;
    	pinConfig.sdaAltNum = 4;
    	pinConfig.sdaCh = Gpio::_ChB;
    
    	i2c.ConfigPins(pinConfig);
    	wpPin.Initialize(Gpio::_ChA, 2, Gpio::_High);
    }
    
    ///sends one byte
    void I2cEeprom::WriteByte(const uint8_t txData, uint8_t wordAddress)
    {
    	WpDisable();
    	i2c.WriteByte(txData, dev_write_addr);
    	WpEnable();
    }
    

                                                                         按页写eeprom.


    我们可以看到Eeprom的页写,页写比单节写效率更高。每页大小是8字节。代码如下。PS(里面调用的是I2c读写多个字节WriteBytesWithHeader函数)

    ///Write a number of bytes in a EEPROM write cycle
    ///However,the number of bytes written at a time can not exceed the size of the EEPROM page
    ///The AT24C02 has 8 bytes per page
    void I2cEeprom::WritePage(uint8_t *txData, uint8_t size, uint8_t wordAddress)
    {
    	uint8_t bytesThisCycle = 0;
    
    	bytesThisCycle = _I2cPageSize - (wordAddress & 0X07);
    
    	WpDisable();
    
    	while (size > 0)
    	{
    		if (size < bytesThisCycle) bytesThisCycle = size;
    
    		i2c.WriteBytesWithHeader(txData, bytesThisCycle, wordAddress, dev_write_addr);
    
    		txData += bytesThisCycle;
    		wordAddress += bytesThisCycle;
    		size -= bytesThisCycle; 
    		bytesThisCycle = _I2cPageSize;
    
    		System::DelayUs(10000);
    	}
    
    	WpEnable();
    }页写分析:我们在页写的时候算出Eeprom的启始地址,数据启始地址,还剩多少字节传输。


    随机读eeprom 


    我们可以看到eeprom的随机读,它是先用写一个设备地址然后一个字节地址,但是里面不能有数据传输和停止信号的一个伪写,当写发送一个启始信号。接着用read发送正常的读信号。代码如下。

    ///read multiple bytes
    uint8_t I2cEeprom::ReadBytes(uint8_t* rxData, uint8_t rxSize, uint8_t wordAddress)
    {
    	i2c.DisableAutoStop();
    	i2c.WriteByte(wordAddress,dev_write_addr);
    	while ( !i2c.IsTransferComplete() ) {}
    	i2c.ReadBytes(rxData, rxSize, dev_read_addr);
    	while ( !i2c.IsTransferComplete() ) {}
    	i2c.ManualStop();
    	i2c.EnableAutoStop();
    }
    代码分析:里面调用了I2c写一个字节但是里面已经使停止信号失能,然后就是调用读多个字节。如果需要源代码可以留言。
    
    

    主函数如下:

    int main(void)
    {
    	uint8_t write[] = {1,2,3,4,5,6,7,8,9,10,11};
    	uint8_t read[11] = {};
    
    	System::Initialize();
    	System::ConfigureForHsi();
    	i2ceeprom.Initialize(1);
    
    	while (1)
    	{
    		i2ceeprom.WritePage(write,5, 0xa8);
    		System::DelayUs(10000);
    		i2ceeprom.ReadBytes(read, 5, 0xa8);
    		System::DelayUs(10000);
    	}
    }
    

    最后我们看一下逻辑分析仪的结果吧。

         

    我们可以看到与手册里面的写时序是一样的。里面160是设备地址10100000,168是字节地址。



    我们看一写读时序,我们之前看了随机读的时序图,所以我们知道要先伪写入一个设备地址一个字节地址,有一个开始信号,然后再一个开始信号(图中绿色的点是开始信号,红色是停止信号。)



    eeprom的读写大概就是这样的啦。如果想参考源代码,可以留言。







        

    展开全文
  • 今天看了open函数,看到w+ r+ a+ 这种可读可写的操作。尝试了几次发现,理解很混乱。运行f.close()之后,写入操作才算是完成。那么f关闭之后,再去读它就会出现报错。所以我自己做了一个对比测试: ...
  • C语言 文件读写的实现

    千次阅读 2019-04-26 11:56:39
    关于C语言的文件读写,我将介绍下面这几种方式: 字符的读写:使用 fgetc() 函数 和 fputc() 函数; 字符串的读写:使用 fgets() 函数和 fputs() 函数; 格式化的读写(主要用于文本文件):使用 ...
  • 硬盘的读写原理详解

    万次阅读 多人点赞 2020-06-14 05:49:21
    硬盘的种类主要是SCSI 、IDE 、以及现在流行的SATA等;任何一种硬盘的生产都要一定的标准;随着相应的标准的升级,硬盘生产技术也在升级;比如 SCSI标准已经经历了SCSI-1 、SCSI-2、SCSI-3;其中目前咱们经常在...
  • C语言文件读写操作总结

    万次阅读 多人点赞 2012-11-26 20:07:02
    C语言文件读写操作总结 C语言文件操作 一、标准文件的读写 1.文件的打开 fopen() 文件的打开操作表示将给用户指定的文件在内存分配一个FILE结构区,并将该结构的指针返回给用户程序,以后用户程序就可用此...
  • android 读写sd卡的权限设置

    万次阅读 多人点赞 2014-08-04 17:14:40
    在Android中,要模拟SD卡,要首先使用adb的mksdcard命令来建立SD卡的镜像,如何...懂Linux的人都知道,这样的权限是无法在SD开中写入内容的,也就无法建立目录.Android中对sd卡的读写权限问题  但是,我们在adb sh
  • 一、MySQL读写分离 1.1 什么是数据读写分离 把客户端访问数据时的查询请求和写请求分别给不同的数据库服务器处理。 1.2 为什么要对数据做读写分离 减轻单台数据库服务器的并发访问压力 提高数据库服务器硬件利用...
  • iOS学习之 plist文件的读写

    万次阅读 多人点赞 2012-10-31 10:08:29
    在做iOS开发时,经常用到到plist文件, 那plist文件是什么呢?...Plist文件通常用于储存用户设置,也可以用于存储捆绑的信息我们创建一个项目来学习plist文件的读写。1、创建项目Plistdemo项目创建之
  • C++读写txt文件(基本操作1)

    万次阅读 多人点赞 2019-06-12 20:05:27
    本博客主要写了用C++读写txt本文的基本操作,最简单的写入和读出两个基本操作。 本程序的功能是向Test.txt文件文件写入字符串"This is a Test12!"和读取字符串"This is a Test12!",并且将读取到的字符串存到temp...
  • PCIE的三种事务读写:存储器读写、配置读写、I/O读写配置读写:配置读写请求TLP是使用“基于ID路由”的一组重要报文,其主要作用是读写PCIE总线的EP、switch以及PCIE桥片的配置寄存器以完成总线的配置。存储器读写:...
  • C++读写EXCEL文件方式比较

    万次阅读 多人点赞 2015-01-19 02:40:48
    因为有些朋友问代码的问题,将OLE读写的代码分享在这个地方,大家请自己看。 http://blog.csdn.net/fullsail/article/details/8449448 C++读取Excel的XLS文件的方法有很多,但是也许就是因为方法太多,大家在选择...
  • 【mysql 读写分离】10分钟了解读写分离的作用

    万次阅读 多人点赞 2017-12-13 17:04:31
    1、what 读写分离 读写分离,基本的原理是让主数据库处理事务性增、改、删操作(INSERT、UPDATE、DELETE),而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。2、...
  • C++读写文本数据

    万次阅读 多人点赞 2019-10-22 21:49:19
    1、C++读写二进制文件 /***************************************************************** * \author DreamerZhang * \date 2019.08.27 * \brief 读取二进制文件,数据类型为short * \param fileName-...
  • 最近买了一个移动硬盘,发现在mac osx上可读不可写,以为移动硬盘有问题,但是却可在我的windows本上完美读写,于是百度了一下。发现其实最早在OSX 10.5的时候,OSX其实原生就支持直接写入NTFS的盘的,后来由于微软...
  • 数据库的读写分离

    万次阅读 多人点赞 2013-04-08 23:03:27
    读写分离,基本的原理是让主数据库处理事务性增、改、删操作(INSERT、UPDATE、DELETE),而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。  为什么要分库、分表、...
  • 随机读写 vs 顺序读写

    2019-12-09 14:24:26
    机械盘:数据是存储的扇区的,读写是依靠磁头的摆动寻址的。顺序读写主要时间花费在了传输时间,随机读写需要多次寻道和旋转延迟。 固态盘:是由控制单元和固态存储单元(DRAM或FLASH芯片)组成,存储单元负责存储...
  • redis读写性能测试

    万次阅读 2013-11-21 02:03:18
     redis读写性能测试redis官网测试读写能到10万左右,非常吸引人,我在研发环境对redis进行测试,发现redis的速度的确很快,此测试是为日后应用优化提供研发参考。由于受到网络环境的限制,本机是100M的网卡,最高10...
1 2 3 4 5 ... 20
收藏数 1,089,735
精华内容 435,894
关键字:

读写