精华内容
下载资源
问答
  • 环境:VS2013 C语言 最近在处理一些较大的数据,今天想要将一组超过百G的信号采集数据进行信号处理后,在重新存储起来,作为后续程序的起始数据。 在看了网上诸多的什么比如用类人算的方法将整数拆解为2进制、直接...

    2020年7月6日 23:17:31

    环境:VS2013 C语言

    最近在处理一些较大的数据,今天想要将一组超过百G的信号采集数据进行信号处理后,在重新存储起来,作为后续程序的起始数据。

    在看了网上诸多的什么比如用类人算的方法将整数拆解为2进制、直接存储整数格式等建议之后,我感觉这些都不是我想要的。

    受到读取数据16bit有符号数据的启发:(如下,小端模式)
    小端模式16bit有符号数据

    我也想将存储的数据也得到类似于此的性能,即存储数据的大小SizeF严格遵循

    SizeF = 2(Byte)* Fs * t

    其中Fs为采样率,t为采样时间。

    但是使用整形数据直接储存或16进制直接储存并不能满足。

    最后我将本问题的解决方案定为:也就是想要读取一组格式为小端模式的16bit有符号数据,并将其进行信号处理后,重新以最有效的16bit有符号数据格式存储(大端模式)起来。。最后也实现了。

    一开始的测试,用了一个大小(393750kB)的原数据做例子:

    测试结果
    以上为测试的结果,从上到下分别以5位整数(%5d)、4位16进制(%04x)以及16位2进制的不同方式存储。

    可以很明显的看出存储方式对空间利用的优化。

    其实实现的代码也很简单:

    对小端模式的16bit读取重组(作者电脑C以大端模式读取数据),代码如下:

    int tek_read(int i_offset, long long int offset, int readSum)
    {
        FILE *odata = NULL;
        char *obuf = NULL;
        size_t bytes_read;
        //int16_t mid_data[DATA_BUF_SIZE];
        int16_t *mid_data;
        mid_data = (int16_t *)calloc((2 * readSum), sizeof(int16_t));
        int16_t temp = 0x00ff;
        int16_t temp1 = 0x0000;    //用来屏蔽污染中间变量,详情见下
        int i, j, l;
        int d, length = 0;
        int flag = 10;
    
        if (mid_data == NULL)
        {
            return FAILURE;
        }
    
        odata = fopen(DATA_name, "r+");
        if (odata == NULL)
        {
            free(mid_data);
            return FAILURE;
        }
        obuf = (char *)malloc((readSum * 2) * sizeof(char));    //动态分配内存 储存连续readSum *16b 数据
        if (obuf == NULL)
        {
            free(mid_data);
            free(obuf);
            return FAILURE;
        }
        long long int t_offset;
        t_offset = i_offset * offset * 2;
        flag = _fseeki64(odata, t_offset, 0);
    
        bytes_read = fread(obuf, 1, (2 * readSum), odata);
    
        fclose(odata);
    
        if (bytes_read < (2 * readSum + 1))
        {
            for (i = 0; i < (2 * readSum); i++)
            {
                mid_data[i] = obuf[i];
            }
            memset(Iri_data, 0, (2 * readSum));    //将Iri_data元素换成0
            for (j = 0; j < readSum; j++)
            {
                Iri_data[j] = mid_data[2 * j + 1];
                Iri_data[j] <<= 8;
                temp1 = mid_data[2 * j] & temp;    //某些低8位(类型是16位)的前8位读成ff导致或运算之后最终前8位成为ff,
                //为避免污染,先与0x00ff与运算
                Iri_data[j] |= temp1;
            }
    
            free(obuf);    //读到Iri_data中后就释放内存
            //数组长度
            d = 0;
            l = 0;
            //可能有连续5个0????末尾是0导致的问题
           free(mid_data);        //释放中间内部
            return length;
        }
        else
        {
            printf("* I am sorry to tell u there is a trouble                    \nin taking Tektronix DATA!\nPlease cheak your settings!  \n");
    
            free(mid_data);        //释放中间内存
            return 0;
        }
    }
    

    中间的信号处理就不详细介绍了
    最后的大端模式将16bit有符号数据写入文件,实现代码:
    复制代码

    int outfile(void)
    {
    
        FILE *fp_out;
        fp_out = fopen(outname, "a+");
        for (int i = 0; i < length_90ms_7Mhz; i++)
        {
            int16_t temp = Iridium_result_D16[i];
                    //大端模式
            fputc((temp >> 8) & 0xFF, fp_out);
            fputc(temp & 0xFF, fp_out);
        }
        fclose(fp_out);
    
        return SUCCESS;
    }
    

    对于我200个G的原始数据,预处理效果很理想。

    存储数据效果如下:
    在这里插入图片描述
    2020年7月7日18:13:34 sun 修改
    在使用整个程序发现了一些问题并相应的进行了一些修改,记录如下。
    首先,由写入数据部分的启发,将读取原数据部分(即读取小端模式,16bit有符号数据)修改为:

    int data_read(int i_offset, long long int offset, int readSum)
    {
    	FILE *odata = NULL;
    	int16_t mid_data = 0;
    
    	int16_t temp = 0x0000;	//用来作为中间变量,详情见下
    	int length = 0;
    	int flag = 10;
    	
    	odata = fopen(DATA_name, "r+");
    	if (odata == NULL)
    	{
    		return FAILURE;
    	}
    
    	long long int t_offset;
    	t_offset = i_offset * offset * 2;
    	flag = _fseeki64(odata, t_offset, 0);
    
    	memset(Iri_data, 0, readSum);	//将Iri_data元素换成0
    	for (int i = 0; i < readSum; i++)
    	{
    
    		char obuf0 = fgetc(odata);
    		char obuf1 = fgetc(odata);
    		Iri_data[i] = obuf1;
    		Iri_data[i] << 8;
    		Iri_data[i] &= 0xff00;
    		temp = obuf0 & 0x00ff;
    		Iri_data[i] |= temp;
    
    		length = i + 1;
    	}
    
    	fclose(odata);
    
    	return length;
    }
    

    在以上的写入数据程序,我发现写入数据的文件大小总是和理论上的不同,数据的实际大小总是略大于计算的大小,而用查看文件时其数目也与我写入的数据不符,查了一圈资料,发现了问题,要用2进制(wb)方式写入:

    int data_outfile(int i_offset, long long int offset, int writeSum)
    {
    
    	FILE *fp_out;
    	fp_out = fopen(outname, "ab+");
    	int flag = 10;
    
    	for (int i = 0; i < writeSum; i++)
    	{
    		int16_t temp = Iridium_result_D16[i];
    
    		//大端模式
    		fputc((temp >> 8) & 0xFF, fp_out);
    		fputc(temp & 0xFF, fp_out);
    	}
    	fclose(fp_out);
    
    	return SUCCESS;
    }
    

    ab+是在文件末尾以2进制格式写入,
    类似于上上部分,读取自己写入的数据的程序如下,注意(rb+):

    int data_read(int i_offset, long long int offset, int readSum)
    {
    	FILE *odata = NULL;
    	size_t bytes_read;
    	int16_t mid_data = 0;
    	int16_t temp = 0x0000;	//中间变量,详情见下
    	int length = 0;
    	int flag = 10;
    
    	odata = fopen(DATA_name, "rb+");
    	if (odata == NULL)
    	{
    		return FAILURE;
    	}
    
    	long long int t_offset;
    	t_offset = i_offset * offset * 2;
    	flag = _fseeki64(odata, t_offset, 0);
    
    	//bytes_read = fread(obuf, 1, (2 * readSum), odata);
    	memset(Iri_data, 0, readSum);	//将Iri_data元素换成0
    	//使用fgetc,不需要obuf使用
    	for (int i = 0; i < readSum; i++)
    	{
    		char obuf0 = fgetc(odata);
    		char obuf1 = fgetc(odata);
    
    		mid_data = obuf0;
    		mid_data << 8;
    		mid_data &= 0xff00;
    		temp = obuf1 & 0x00ff;
    		mid_data |= temp;
    		Iri_data[i] = mid_data;
    
    		length = i + 1;		//读取长度
    	}
    
    	fclose(odata);
    
    	return length;
    }
    

    struct Information
    {
    char Name = {‘BIOSmode’};
    char Email = {‘sunguiyu96@gmail.com’};
    char github = {‘https://github.com/BIOSmode’};
    } ;

    展开全文
  • 【C】C语言文件(包括:文件各种读写方式

    万次阅读 多人点赞 2018-05-09 09:52:32
    文件概述 文件是指存储在外部存储器上的数据集合。更准确的来说,文件就是一组...ASCII文件(文本文件):以字符的方式进行存储,一个字符对应一个ASCII码,而一个ASCII码占用1字节。例如:整数12在内存中占用4个字...

    文件概述

    文件是指存储在外部存储器上的数据集合。更准确的来说,文件就是一组相关元素或数据的有序集合,而且每个集合都有一个符号化的指代,称这个符号化的指代为文件名。

    文件类型

    根据文件在外部存储器上的组织形式,文件可以分为ASCII文件和二进制文件。

    • ASCII文件(文本文件):以字符的方式进行存储,一个字符对应一个ASCII码,而一个ASCII码占用1字节。例如:整数12在内存中占用4个字节;如果按照ASCII码的方式存储,则占用2个字节。ASCII文件可以阅读,可以打印,但是它与内存数据交换时需要转换;
    • 二进制文件:将内存中的数据按照其在内存中的存储形式原样输出并保存在文件中。二进制文件占用空间小,内存数据与磁盘数据交换时无需转换,可以节省外存空间和转换时间。但是二进制文件不可阅读、打印。

    在C语言中,扩展名为.c的源文件是由字符构成,而扩展名由.obj目标文件和.exe可执行文件是由二进制符号构成的。其实:txt文件也是一个文本文件。

    C如何操作文件——文件指针

    C语言是通过文件指针变量的操作来实现对文件的具体访问。

    文件的指针不是指向一段内存空间,而是指向描述有关这个文件的相关信息的一个文件信息结构体,该结构体定义在studio.h头文件中。当然,也无需了解有关此结构体的详细细节,只需要知道如何使用文件指针就行了。

    声明文件指针变量的一般形式为:

    FILE* 文件型指针变量名;

    其中,FILE应为大写;它实际上是由系统定义的一个结构体,该结构体中包含了文件名、文件使用方式、当前位置等信息

    在stdio.h文件中,FILE的结构体定义为:

    typedof atruct
    {
        int _fd;            /* 文件号 */
        int _cleft;            /* 缓冲区剩下的字符 */
        int _mode;            /* 文件操作模式 */
        char* _nextc;            /* 下一个字符的位置 */
        char* _buff;            /* 文件缓冲区位置 */
    }FILE;

    文件缓冲区

    由于文件存储在外存储器上,外存的数据读/写速度相对较慢,所以在对文件进行写/读操作时,系统会在内存中为文件的输入或输出开辟缓冲区。

    • 当对文件进行输出时,系统首先把输出的数据填入为该文件开辟的缓冲区内,每当缓冲区被填满时,就把缓冲区中的内容一次性输出到对应的文件中;
    • 当从某个文件输入数据时,首先将从输入文件中输入一批数据放入到该文件的内存缓冲区中,输入语句将从该缓冲区中依次读取数据;当该缓冲区的数据被读完时,将在从输入文件中输入一批数据到缓冲区。

     

    文件的打开与关闭

    C语言规定,任何文件在使用之前必须打开,使用之后必须关闭。对文件的操作都是通过标准函数来实现的。

    文件的打开——fopen()函数

    C语言用fopen()函数打开一个文件,其调用的一般形式为:

    文件指针名 = fopen(文件名,文件的使用方式);

    该函数可以通过对文件指针名的判断来对文件打开进行判断,如果文件指针名为NULL,则文件打开失败;否则打开成功。

    文件的使用方式和含义如下表所示:

    文件的使用方式和含义
    打开方式 含义 指定文件不存在时 指定文件存在时
    r 只读方式打开文本文件 出错 正常打开
    w 只写方式打开文本文件 建立新文件 文件原有内容丢失
    a 追加方式打开文本文件 建立新文件 在原有内容末尾追加

    r+

    读/写方式打开文本文件 出错 正常打开
    w+ 读/写方式创建新的文本文件 建立新文件 文件原有内容丢失
    a+ 读/追加方式建立新的文本文件 建立新文件 在原有内容末尾追加
    rb 只读方式打开二进制文件 出错 正常打开
    wb 只写方式打开二进制文件 建立新文件 文件原有内容丢失
    ab 追加方式打开二进制文件 建立新文件 在原有内容末尾添加
    rb+

    读/写方式打开二进制文件

    出错 正常打开
    wb+ 读/写方式创建新的二进制文件 建立新文件 文件原有内容丢失
    ab+ 读/追加方式创建新的二进制文件 建立新文件 在原有内容末尾追加

    高版本的VS编译器可能会认为fopen()函数不安全,会强制要求使用fopen_s()函数来代替。

    fopen_s()函数调用的一般形式为:

    errno_t err;
    err = fopen_s(指向文件指针的指针,文件名,文件的使用方式);
    err = fopen_s(&fp,"d:\\1.txt","r");

    这个函数的使用有两点注意:

    • 该函数有返回值,如果打开文件成功,函数返回值为0;否则返回值非0;
    • 该函数的第一个参数时指向文件指针的指针,也就是说,需要传递文件指针的地址。

    文件的关闭——fclose()函数

    在程序中,当对一个文件的操作使用完毕后,应将其关闭,断开文件指针与该文件之间的联系,防止文件遭到其他操作的破坏。C语言用fclose()函数打开一个文件,其调用的一般形式为:

    fclose(文件指针);

    该函数有返回值,如果关闭文件成功,函数返回值为0;否则返回值非0。

     

    文件的顺序读/写

    字符读/写函数fgetc()和fputc()

    fgetc()函数的功能是从指定的文件中读取一个字符,其调用的形式为:

    字符变量 = fgetc (文件指针);

    如果在执行fgetc()函数时遇到文件结束符,函数会返回一个文件结束符标志EOF(-1)。

    fputc()函数的功能是把一个字符写入指定的文件中,其一般调用的格式为:

    fput(字符,文件指针);

    例子:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
    	FILE* fp1, *fp2;
    	errno_t err;
    	char c;
    
    	err = fopen_s(&fp1, "d:\\1.txt", "w");
    	if (err != 0) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	c = getchar();
    	while (c != '\n') {
    		fputc(c, fp1);
    		c = getchar();
    	}
    	fclose(fp1);
    
    	err = fopen_s(&fp2, "d:\\1.txt", "r");
    	if (err != 0) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	c = fgetc(fp2);
    	while (c != EOF) {
    		printf("%c", c);
    		c = fgetc(fp2);
    	}
    	printf("\n");
    	fclose(fp2);
    
    	return 0;
    }

    从上面的例程可以看出,文件的顺序读/写函数仅仅是沟通文件和程序之间的函数,如果想要从键盘上输入或者输出到命令行等,还是需要我们之前学到的输入输出的内容,不会的可以参考链接【编程语言】C语言基础(包括:关键字、数据类型、输入输出)

    字符串读/写函数fgets()和fputs()

    fgets()函数的功能是从指定的文件中读取一个字符串,其调用的形式为:

    fgets(字符数组名,n,文件指针);

    其中,n是一个正整数,表示从文件中读出的字符串不超过n-1个字符。在读入一个字符串后加上字符串结束标志'\0'。

    如果在执行fgets()函数时如果文件内的字符串读取完毕,函数会返回0。

    fputs()函数的功能是把一个字符串写入指定的文件中,其一般调用的格式为:

    fputs(字符串,文件指针);

    其中,字符串可以是字符串常量、字符数组、字符指针变量。

    例子:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
    	FILE* fp1, *fp2;
    	errno_t err;
    	char s[30];
    
    	err = fopen_s(&fp1,"d:\\1.txt", "w");
    	if (err != 0) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	gets(s);
    	while (strlen(s) > 0) {
    		fputs(s, fp1);
    		gets(s);
    	}
    	fclose(fp1);
    
    	err = fopen_s(&fp2, "d:\\1.txt", "r");
    	if (err != 0) {
    		printf("文件打开失败!\n");
    		exit(0);
    	}
    	while (fgets(s, 11, fp2) != 0) {
    		printf("%s", s);
    	}
    	printf("\n");
    	fclose(fp2);
    
    	return 0;
    }

    数据块读/写函数fread()和fwrite()

    读数据块函数fread(),其调用的一般形式为:

    fread(buf,size,n,文件指针);

    fread()函数的功能是从文件中读取字节长度为size的n个数据,并存放到buf指向的内存地址中去。

    函数的返回值为实际读出的数据项个数。比如:

    fread(fa,4,5,fp);

    其意义是从fp所指向的文件中,每次读4个字节长度(int)送入到fa指向的内存地址中去,连续读5次。也就是说,读5个int类型的数据到fa指向的内存中。

    写数据块函数fwrite(),其调用的一般形式为:

    fwrite(buf,size,n,文件指针);

    fread()函数的功能是将buf中存放的size*n个字节的数据输出到文件指针所指向的文件中去。

    函数的返回值为实际写入的数据项个数。

    fread()和fwrite()函数一般适用于二进制文件,它们是按数据块的大小来处理输入/输出的。

    格式化读/写函数fscanf()和fprintf()

    格式化读/写函数与标准的格式输入/输出函数功能相同,只不过它们的读/写对象不是键盘和显示器,而是文件。fscanf()和fprintf()函数只适用于ASCII码文件的读/写。

    两个函数的格式如下:

    fscanf(文件指针,格式字符串,输入列表);
    fprintf(文件指针,格式字符串,输出列表);

    fscanf()和fprintf()函数对文件进行读/写,使用方便,容易理解。但由于在输入时需要将ASCII码转换为二进制格式,在输出时又要将二进制格式转换为字符,花费时间较长,所以在内存与磁盘交换数据频繁的时候,最好不要用这两个函数。

     

    文件定位与文件的随机读/写

    在C语言中,打开文件时,文件指针指向文件头,即文件的起始位置。在读写文件时,需要从文件头开始,每次读写完一个数据后,文件指针会自动指向下一个数据的位置。但有时不想从文件头开始读取文件,而是读取文件中某个位置的数据。这时,系统提供了定位到某个数据存储位置的函数。

    文件头定位函数rewind()

    rewind()函数用于把文件指针移动到文件首部,其调用的一般形式为:

    rewind(文件指针);

    当前读/写位置函数ftell()

    ftell()函数用于确定文件指针的当前读/写位置,其调用的一般形式为:

    ftell(文件指针);

    此函数有返回值,若成功定位,则返回当前位置;否则返回-1。

    随机定位函数fseek()

    fseek()函数用于将文件指针移动到某个确定的位置,其调用的一般形式为:

    fseek(文件指针,位移量,起始点);

    此函数有返回值,若成功移动,则返回当前位置;否则返回-1。

    其中:位移量指从起始点向前移动的字节数,大多数C版本要求该位移量为long型数据;起始点有三种选择,具体的含义见下表:

    起始点取值含义
    起始点 表示符号 数字表示
    文件首 SEEK_SET 0
    当前位置 SEEK_CUR 1
    文件尾 SEEK_END 2

    例如,将指针位置移动到距离文件开头100字节处:

    fseek(fp,100L,0)

    注意:fseek()函数一般用于二进制文件,因为文本文件计算位置往往比较混乱,容易发生错误。

     

    文件检测函数

    C语言还提供了一些检测函数,用于在文件打开、关闭以及读/写操作过程中对有可能会发生的一些情况进行检测。

    文件结束检测函数feof()

    feof()函数用于判断文件是否处于文件结束为止,其调用的一般格式为:

    feof(文件指针);

    该函数有返回值,如果文件结束,函数的返回值为1;否则返回值为0。

    读/写文件出错检测函数ferror()

    ferror()函数用于检查文件在使用各种读/写函数时是否出错,其调用的一般格式为:

    ferror(文件指针);

    该函数有返回值,如果没有错误,函数的返回值为0;否则返回值非0。

    文件出错标志清除函数clearerr()

    clearerr()函数用于清除出错标志,其调用的一般格式为:

    clearerr(文件指针);

    在ferror()函数值为非0时,在调用此函数后,ferror()函数的值变为0。

     

    展开全文
  • c语言这么一门关键的操作,他就是文件操作。 文件操作c语言中具体的文件操作二级目录三级目录 c语言中具体的文件操作 在c语言中具体的文件操作是通过...在文件操作的代码中很多文件的使用方式例如上面的"r"就

    在c语言中有这么一门关键的操作,他就是文件操作。

    c语言中具体的文件操作

    在c语言中具体的文件操作是通过库函数进行实现的。
    其中最关键的函数就是fopen()函数
    该函数是文件打开函数,通过此函数可以对文件进行操作,具体代码如下:
    FILE* pf = fopen(“data.txt” , “r”);
    上面的代码就是通过fopen()函数将计算机中的data.txt文件进行读操作。并将其地址赋值给pf。
    在文件操作的代码中有很多文件的使用方式例如上面的"r"就是文件操作中的读操作。如下图:

    文件使用方式        概念
    “rt”       只读打开一个文本文件,只允许读数据
    “wt”      只写打开或建立一个文本文件,只允许写数据
    “at”      追加打开一个文本文件,并在文件末尾写数据
    “rb”      只读打开一个二进制文件,只允许读数据
    “wb”       只写打开或建立一个二进制文件,只允许写数据
    “ab”       追加打开一个二进制文件,并在文件末尾写数据
    “rt+”      读写打开一个文本文件,允许读和写
    “wt+”      读写打开或建立一个文本文件,允许读写
    “at+”      读写打开一个文本文件,允许读,或在文件末追加数 据
    “rb+”      读写打开一个二进制文件,允许读和写
    “wb+”      读写打开或建立一个二进制文件,允许读和写
    “ab+”      读写打开一个二进制文件,允许读,或在文件末追加数据

    而且在文件操作中具体的库函数有这么几种:

    fputc(int c , FILE* stream)函数
    该操作指的是将 一个字符写进文件,具体代码如下:
    在这里插入图片描述
    上面的代码就是先读datat.txt文件并将其地址放到指针pf中之后将字符a到z写进文件datat.txt中。


    fgetc(FILE* stream)函数
    该操作是将文件中的字符进行读入并赋值到一个变量中并将其输出具体代码如下:

    在这里插入图片描述
    上面的代码就是先读文件datat.txt并将其地址赋给pf,之后对pf进行判断随后讲文件中的字符一个一个的输出直到到文件尾部位置为止。


    fputs(const char* string , FILE* stream)函数
    该函数和fputc()相似是将前面的字符串输入到文件中具体代码如下:
    在这里插入图片描述


    fgets(char* string , int n , FILE* stream)函数
    该函数是将文件中的n - 1个字符存到string中并可以进行输出,此处为n - 1的原因是因为最后要将’\0’存储到string中所有只能存储文件中的n - 1个字符。具体代码如下:
    在这里插入图片描述


    fprintf(FILE* stream , const char* format , …)函数
    该函数表示的是格式化写入,具体就是将结构体中的成员的数据直接写入文件中。具体代码如下:
    在这里插入图片描述


    fscanf(FILE* stream , const char* format , …)函数
    该函数表示的是格式化的读取,将文件中的数据输入到结构体s中并将其输出。具体代码如下:
    在这里插入图片描述


    sscanf(const char* buffer , const char* format , …)函数
    该函数是将字符串读取格式化输入,函数可以将字符串的数据转换成一个结构体。具体代码如下:
    在这里插入图片描述


    sprintf(char* buffer , const char* format)函数
    该函数是可以把结构体中的数据转换成一个字符串之后并进行输出。代码如下:
    在这里插入图片描述


    fwrite()函数与fread()函数

    fwrite()函数是将信息以二进制的形式放在文件中。
    struct Stu s
    {
    char name[30];
    int age;
    float score;
    };

    int main()
    {
    struct Stu s = { “zhangsan”, 19, 65.5 };
    FILE* pf = fopen(“datat.txt”, “wb”);
    if (pf == NULL)
    {
    printf("%s\n", strerror(errno));
    return 1;
    }

    //写文件
    fwrite(&s, sizeof s, 1, pf);//以二进制的形式放进文件中
    

    /此函数的内容是将结构体中大小为sizeof(s)的count个元素放到流里面去/

    fclose(pf);
    pf = NULL;
    return 0;
    

    }

    上面的代码是将结构体s中类型大小是sizeof s的1个元素放到建立的文件datat.txt的地址中。

    fraed()函数是读文件,将文件中的数据读入到结构体中并进行输出。具体代码如下:

    在这里插入图片描述
    上面的函数是将文件datat.txt的地址pf中大小是sizeof s的个数是1的数据放到变量s中并将结构体s进行输出。


    将通讯录中的信息存储到文件中

    在之前写的通讯录中只能存储一次信息,在程序结束之后该通讯录中信息就会被删除,所以此时运用所学的文件操作就可以将其存到一个二进制文件中进行存储。具体代码如下:
    在这里插入图片描述
    此函数是将通讯录中的信息以二进制的形式存储到文件contact.dat中。但是当该程序进行初始化操作的时候又会将通讯录中的信息重新进行输入,还是存储不了,所以此时可以在初始化通讯录的时候进行直接将文件contact.dat中的内容放到通讯录中,这样就可以在通讯录中保存住之前存储的信息。具体代码如下:
    头文件定义基础变量和函数:
    在这里插入图片描述
    操作文件中实现函数

    在这里插入图片描述
    主文件进行主操作

    在这里插入图片描述
    这就是关于文件操作和通讯录保存信息的操作的具体内容。

    展开全文
  • C语言各种变量存储方式

    千次阅读 2015-03-20 15:11:49
    1、变量类型:C语言的变量分为局部变量和全局变量。 1.局部变量: 指在函数内部或者块内部(即一对花括号包含的区域)[以下均称为块]定义的变量,只对块范围内有效。 特点:不同块中可以同名变量名,代表不同的...

    1、变量类型:

    C语言的变量分为局部变量和全局变量。
    1.局部变量:
    指在函数内部或者块内部(即一对花括号包含的区域)[以下均称为块]定义的变量,只对块范围内有效。
    特点:不同块中可以有同名变量名,代表不同的变量,互不干扰;函数形参也是局部变量。
    2.全局变量:
    在函数之外定义的变量,从定义处开始到文件结束均有效,当然可以使用extern修饰将其范围扩大到其他文件。
    特点:如果局部变量和全局变量同名,那么在局部变量作用范围内外部变量不起作用;在不必要是尽量不要使用全局变量,因为其降低了函数的通用性。

    2、实验

    另外加上static和const关键字之后,这些变量又是怎么存储的呢?下面的代码在linux系统调试通过:

    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
      int int_a=1; 
      static int static_int_a=2;
      const  int const_int_a=3;
    int main ()
    {
      int int_b=1; 
      static int static_int_b=2;
      const  int const_int_b=3;
      int *p1=malloc(4);
    
      printf("       int_a: %p\n",&int_a);
      printf("static_int_a: %p\n",&static_int_a);
      printf(" const_int_a: %p\n",&const_int_a);
      printf("       int_b: %p\n",&int_b);
      printf("static_int_b: %p\n",&static_int_b);
      printf(" const_int_b: %p\n",&const_int_b);
      printf("           p: %p\n",&p1);
      printf("        main: %p\n",main);
    
     printf("%d\n",getpid());
     while (1);
    }
    

    下图是调试结果:

    这里写图片描述

    下图是程序运行时的maps文件:
    这里写图片描述

    3、结果

    通过上面的代码实验可以看出
    1、 普通全局变量和static修饰的全局变量存放在全局区(程序运行时把这些数据存进栈中),但是const修饰的全局变量存放在代码区(程序运行时该数据存在只读Memory中)。
    2、 普通局部变量和const修饰的局部变量存放在栈里面,但是static修饰的存放在了全局区。

    4、杂记

    一、const修饰符
    1.修饰的变量必须初始化:

     const int i=1;//合法
        const int j;//非法

    2.被修饰的变量只能被读:

     const int i=1;
        int j=2;
        i=j;//非法
        j=i;//合法

    3.可以避免不必要的内存分配:

     #define STR "abcdef"
        const char str[]="abcdef";    
        printf(STR);//为STR第一次分配内存
        printf(str);//为str一次分配内存
        printf(STR);//为STR第二次分配内存
        printf(str);//已经不需要分配内存了    
    同样是一个常量字符串,宏定义在编译时候自动替换了,所以实际是很多的常量。
    

    4.数值常量和指针常量区分:

        int x=1;
        const int y=2;          //y是常量,初始化之后就不能修改y值了
        const int *p1=&x;       //p1指向的内容是常量,不可以修改
        int * const p2=&x;      //指针p2是常量,所指向的内容可修改
        const int * const p3=&x;//指针p3和p3指向的内容均不可以修改
        p1=&y;//合法
        *p2=3;//合法

    5.const的常量未必一定不可以修改

       const int x=1;
        int *p=(int*)&x;
        *p=2;//   此时的x的值便被修改为2了
    展开全文
  • C语言 文件

    2018-08-28 11:35:00
    文件:记录在外部介质上的数据的集合,这个数据集一个名称,叫做文件名 使用数据文件的目的: 1.数据文件的改动不引起程序的改动——程序与数据分离。...文件存储方式:顺序存取和直接存取。 ...
  • C语言文件操作大全

    2020-12-25 22:32:38
    C语言访问文件方式一共12种。由这几个关键字组合而成:read,write,append(追加),text(文本文件),banary(二进制文件),+表示读和写。 4、文件的关闭:fclose(); 操作系统对打开的文件数量限制,
  • C语言文件操作

    2020-08-02 21:53:20
    1.文件分为ASCII文件和二进制文件,ASCII文件也称文本文件,由一系列字组成,文件中...C语言访问文件方式一共12种。由这几个关键字组合而成:read,write,append(追加),text(文本文件),banary(二进制文件
  • C语言文件管理

    2017-07-04 10:32:02
    文件操作 /* 1---文件:文件存储在外部介质上的数据的集合 高级文件操作:缓冲区的文件操作 1M 低级文件操作:非缓冲区操作,缓冲区大小程序... 2---C语言操作文件主要以下3个基本步骤: ①打开文件
  • C语言文件打开的模式

    2021-01-20 06:11:06
    C语言访问文件方式一共12种。由这几个关键字组合而成:read,write,append(追加),text(文本文件),banary(二进制文件),+表示读和写。 4、文件的关闭:fclose(); 操作系统对打开的文件数量
  • 变量可以分为全局变量、静态全局变量、局部变量和静态局部变量变量的声明两种情况:1)一种是需要建立存储空间的(定义性声明)。例如int a 在生命的时候就已经建立了存储空间。2)另一种是不需要建立存储空间的...
  • 一.概述: 前面讲了,static和extern对函数的作用,... statuc和extern对变量也作用,不过跟函数有点差别。二.再谈谈全局变量: 1.默认情况下,一个函数不可以访问再它后面定义对全局变量。int main(){ a= 1...
  • C语言文件读写(结构体文件)

    千次阅读 多人点赞 2018-08-01 16:28:00
    时候,我们需要将输入的数据存储起来,这时候就需要用到文件,对于C语言而言,文件的读写多种方式,下面主要是结构体文件的读写,例如student.dat(第一列是学号,第二列是姓名) 20180001 xiaoming ...
  • 这篇文章主要介绍了C语言采用文本方式和二进制方式打开文件的区别分析,助于读者更好的理解文本文件与二进制文件的原理,需要的朋友可以参考下 稍微了解C程序设计的人都知道,文本文件和二进制文件在计算机...
  • 数据文件分为文本文件(以ASCII码的形式存储)和二进制文件(以为二进制的形式存储文件缓冲区 1、从内存向磁盘输入数据会先送到内存中的缓冲区,装满缓冲区之后才一起送到磁盘上(输出);从磁盘上读取数据输入...
  • C语言文件的初步认识

    2018-05-15 14:20:56
    文件是一种信息的存储方式,它指一组已经命名的,存储的在外存储器上的,具有相同性质的信息的集合,文件在程序设计中是一个重要的概念,一个程序的运行往往避免不了要从文件中提取一些数据等。。 文件的概述:文件...
  • C语言文件进阶操作

    2018-06-10 21:11:00
    Description文件a.dic、b.dic、c.dic中分别存张三的三科成绩,每个文件都是16字节:前8个字节存储其英文名字zhangsan,后面是一个空格,其后的2个字节存储其年龄(文本方式存储),后面也是一个空格,最后4个字节...
  • C语言文件操作相关

    2019-05-22 21:28:15
    在程序员和磁盘之间一个文件操作系统(适配层) 在操作系统下只有两种文件:文本文件(ASCLL文件)、二进制文件(内存存储)。 文件的三板斧:打开、读和写、关闭。 打开函数 fopen fopen()函数打开由fname...
  • C语言之变量类型和存储方式

    千次阅读 2017-01-03 17:27:00
    变量的声明两种情况: 1、一种是需要建立存储空间的(定义性声明)。例如int a 在生命的时候就已经建立了存储空间。 2、另一种是不需要建立存储空间的(引用性声明)。例如extern int a 其中变量a是在别的文件中...
  • C语言文件操作 在C语言学习过程中,对于数据的存储是无法避免的问题之一。 我们学习了用数组来存储某一种类型数据,用结构体来存储多种不同类型数据,但是这些都是程序中的容器,程序退出后这些数据也就随之消失了。...
  • C语言文件

    2020-02-15 15:08:24
    所谓的文件并不是存在该项目中的,一般指存储在磁盘上的文件 我们在写c文件的时候经常引用stdio文件,该文件具有一个FILE 结构体类型。用数组存放若干文件。所以,利用这一特点,FILE t[5]表示存放5 个文件的信息...
  • C语言——文件

    2019-02-25 20:20:30
    文件概述   文件是指存储在外部存储器上的数据集合。更准确的来说,文件就是一组相关元素或数据的...ASCII文件(文本文件):以字符的方式进行存储,一个字符对应一个ASCII码,而一个ASCII码占用1字节。例如:整...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390
精华内容 156
关键字:

c语言文件存储方式有

c语言 订阅