c提高

一.内存管理：

内存四区：

1.一个C语言变量的作用域可以是代码块 作用域，函数作用域或者文件作用域。
代码块是{}之间的一段代码

2.register寄存器变量
通常变量在内存当中，如果能把变量放到CPU的寄存器里面，代码执行效率会更高
register int I

3.全局函数和静态函数
在C语言中函数默认都是全局的，使用关键字static可以将函数声明为静态，静态函数只能在当前函数内使用

4.代码区 
代码区code，程序被操作系统加载到内存的时候，所有的可执行代码都加载到代码区，也叫代码段，这块内存是不可以在运行期间修改的。

5.静态区
所有的全局变量以及程序中的静态变量都存储到静态区,比较如下两段代码的区别

6.栈区
栈stack是一种先进后出的内存结构，所有的自动变量，函数的形参都是由编译器自动放出栈中，当一个自动变量超出其作用域时，自动从栈中弹出。

7.堆heap和栈一样，也是一种在程序运行过程中可以随时修改的内存区域，但没有栈那样先进后出的顺序。
堆是一个大容器，它的容量要远远大于栈，但是在C语言中，堆内存空间的申请和释放需要手动通过代码来完成。

8.堆的分配和释放：

malloc：void *malloc(size_t  _size);  malloc函数在堆中分配参数_size指定大小的内存，函数返回void *指针

free：void free(void *p);  free负责在堆中释放malloc分配的内存，参数p为malloc返回的堆中的内存地址

9.malloc、free用法示例：三种结果相同，区别指针用法

第一种：

void getp(int *p){
	printf("%x\n", p);  //31fa48
	printf("%x\n", &p);  //31f974
	printf("%x\n", *p);  //0
	printf("%x\n", *(&p));   //31fa48
	printf("%x\n", **(&p));   //0
	
	*p = malloc(sizeof(int) * 10);
	
}
int main()
{
	int *p = NULL;

	printf("%x\n", &p);   //31fa48
	
	getp(&p);
	p[0] = 1;
	printf("%d\n", p[0]);
	free(p);
	return 0;
}

void getp(int **p){
	printf("%x\n", p);  //31fa48
	printf("%x\n", &p);  //31f974
	printf("%x\n", *p);  //0
	printf("%x\n", *(&p));   //31fa48
	printf("%x\n", **(&p));   //0
	
	*p = malloc(sizeof(int) * 10);
	
}
int main()
{
	int *p = NULL;

	printf("%x\n", &p);   //31fa48
	
	getp(&p);
	p[0] = 1;
	printf("%d\n", p[0]);
	free(p);
	return 0;
}

void getp(int *p){
	printf("%x\n", p);  //31fa48
	printf("%x\n", &p);  //31f974
	printf("%x\n", *p);  //0
	printf("%x\n", *(&p));   //31fa48
	printf("%x\n", **(&p));   //0
	
	**(&p) = malloc(sizeof(int) * 10);
	
}
int main()
{
	int *p = NULL;

	printf("%x\n", &p);   //31fa48
	
	getp(&p);
	p[0] = 1;
	printf("%d\n", p[0]);
	free(p);
	return 0;
}

第四种：

int *getp()
{
	return malloc(100);
}
int main(){
	int *p = NULL;

	p = getp();

	free(p);
	return 0;
}

11.malloc申请的内存是随机的，不连续的，如果想要申请连续内存空间，可以用calloc，calloc用法跟malloc相同，如果malloc或calloc申请的内存空间不够用，想要申请更多空间，可以用realloc，realloc会在原有内存的基础之上，在堆中间增加连续的内存空间，如果原有内存没有连续空间可扩展，就会新分配一个空间，将原有内存copy到新内存，然后释放原有内存

malloc跟realloc分配的内存都不是连续的；

memset：把malloc或realloc申请的不连续的内存空间变成连续的

写法：

char *p=malloc(10);

char *p1=calloc(10,sizeof(char));

char *p2=realloc(p1, 20);  //在原有内存p1基础上，在堆中增加内存

char *p3=realloc(NULL ,  5);   //等同于malloc(5)

memset(p , 0 ,10);   //将不连续的p内存空间变成连续的，从第0个到第10个

12.static int f=0；用static声明的变量会在整个进程运行期间一直有效，是在静态区，但只能在当前函数内使用

13.如果一个函数要修改另一个函数的静态变量的值，可以通过调用函数的方式将这个静态变量返回然后对其修改

14.堆内存的使用情况：

情况一：int set[1000];   此时set数组在栈中，超过了栈的存储空间，，可以用malloc在堆中创建超大数组。int *set=malloc(sizeof(int)* 100000);

情况二：int i=0;  scanf("%d",&i); int array[i];  这种方式创建动态数组会报错，，应该用malloc创建动态数组。int *array=malloc(sizeof(int)*i);  

二.结构体：

结构体的定义与使用

structman
{
   char name[100];
   int age;
};
struct man m = { "tom", 12 };
struct man m= { .name = "tom", .age = 12 };

1.结构体在内存中是个矩形，而不是一个不规则形状

2.结构体在内存的大小取决于结构体中的内容，同样是int4个字节，char1个字节，但是结构体是4的倍数大小，例：A的大小为8个字节，B的大小为12个字节，c也12个字节

struct A{
	int a;
	char b;
	char c;
}
struct B{
	int a;
	int b;
	char c;
}

struct C{
	char a;
	int b;
	char c;
}

struct D{
	char a;
	short b;
	char c;
	int e;
	long long d;
}

struct D {
	char c;
	char a;
	short b;
	int e;
	long long d;
}

	struct test{
		char a : 2;//指定元素为2位长，不是2个字节长
	};

4.结构数组：structman m[10] = { {"tom",12 }, {"marry",10 }, {"jack",9 } };

5.一个结构体的成员还可以是另一个结构体

struct names{
		char first[100];
		char last[100];
	};

	struct man{
		struct names name;
		int age;
	};
	struct man m = { { "wang", "wu" }, 20 };

6.结构体变量之间可以互相赋值（区别数组）

struct str{

	char s[100];
};
int main(){
	
	struct str s1, s2;
	strcpy(s1.s, "hello");//把hello赋给s1.s

	//s2 = s1;	//把s1赋给s2和下面一行代码相同

	//memcpy(&s2, &s1, sizeof(s1));
	printf("%s\n", s2.s);
	return 0;
}

struct str a;
struct str *p = &a;
(*p).a = 10;
(*p).b= 20;
上面的定义方式等同于下面
p->a = 10;
p->b = 20;

指针使用示例：

struct A{
	int a;
	int b;
};

struct A array[10] = { 0 };
p = array;
p->a = 1;
p->b = 2;
p++;
p->a = 3;
p->b = 4;

也可以在堆中申请内存创建数组：

struct A{
	int a;
	int b;
};
p = malloc(sizeof(struct A) * 10);
struct A *array = p;

p->a = 1;
p->b = 2;
p++;
p->a = 3;
p->b = 4;

free(array);

struct str{
	char *name;
	int age;
};

int main(){
	struct str st = { NULL,0 };
	st.age = 30;
	st.name = malloc(100);
	strcpy(st.name, "吴志刚");
	printf("%d,%s\n", st.age, st.name);
	free(st.name);
	return 0;
}

struct st{
	char name[1000];
	int age;
};
void print_student(struct student s){
	printf("name=%s,age=%d\n", s.name, s.age);
}
void set_student(struct student s,const char *name,int age){
	strcpy(s->name, name);
	s->age = age;
}
int main(){

	struct student st = { "tom",20 };
	set_student(&st, "mike", 100);
	print_student(st);  //结果打印出mike  100
	return 0;
}

联合union是一个能在同一个存储空间存储不同类型数据的类型。

联合体所占的内存长度等于其最长成员的长度，也有叫做共用体。

联合体虽然可以有多个成员，但同一时间只能存放其中一种。

对于联合体来讲最基本的原则是，一次只操作一个成员变量，如果这个变量是指针，那么一定是处理完指针对应的内存之后再来使用其他成员。

三.枚举类型

可以使用枚举(enumeratedtype)声明代表整数常量的符号名称，关键字enum创建一个新的枚举类型。

实际上，enum常量是int类型的。

枚举的本质就是int型的常量。

1.默认值

默认时，枚举列表中的常量被指定为0,1,2等

指定值

可以指定枚举中具体元素的值

四.typedef：

typedef是一种高级数据特性，它能使某一类型创建自己的名字

1.与#define不同，typedef仅限于数据类型，而不是能是表达式或具体的值

3typedef比#define更灵活

4.通过typedef定义函数指针

在程序当中如果是定义一个可读的常量，适合用#define

如果定义的是一个具体的数据类型，那么typedef更加适合。

如果是定义一个函数指针，那么基本就typedef吧.

1.不论操作什么类型的文件，第一步先打开一个文件，第二步，读写文件，第三步关闭文件。

2.fopen

r 以只读方式打开文件，该文件必须存在。

r+ 以可读写方式打开文件，该文件必须存在。用r+写文件时候，从文件开始位置写入

rb+ 读写打开一个二进制文件，允许读写数据，文件必须存在。

rw+ 读写打开一个文本文件，允许读和写。

w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。

wb

w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。

a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）,如果文件不存在，a的行为和w是一样的

a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。 （原来的EOF符不保留）

“b”只对windows有效，对于unix来讲是无效，

3.文件操作helloworld案例：

写入文件

int main(){

	char s[1024] = { 0 };
	FILE *p = fopen("D:\\temp\\a.txt", "w");//用写的方式打开一个文件
	//w意思就是如果文件不存在，就建立一个，如果文件存在就覆盖
	while(1){
		memset(s, 0, sizeof(s));
		gets(p);
		if (strcmp(s, "exit") == 0)
			break;
		int len = strlen(s);
		s[len] = &＃39;\n&＃39;;
		fputs(s, p);
	}
	fclose(p);//关闭这个文件
	printf("end\n");
	return 0;
}

int main() {

	char s[1024] = { 0 };
	FILE *p = fopen("D:\\temp\\a.txt", "r");//用读的方式打开一个文件
	while (!feof(p)) {						//feof(p)如果已经到了文件结尾，函数返回真
		memset(s, 0, sizeof(s));
		fgets(s, sizeof(s), p);
		printf("%s", s);
	}
	fclose(p);//关闭这个文件
	return 0;
}

5.getc和putc函数

程序怎么才能知道是否已经到达文件结尾了呢？EOF代表文件结尾
如果已经是文件尾，feof函数返回true。

7.fprintf,fscanf,fgets,fputs函数（都是操作文件的一行，不是单个字符）

这些函数都是通过FILE*来对文件进行读写。

——fprintf：功能和printf一样，fprintf是把数据输出到文件中，fprintf(p,"%s" ,buf);  p是要输出的文件，buf是输出的值

——fscanf与scanf用法基本一致，fscanf是从一个文件读取输入，scanf是从键盘读取输入，用法：fscanf(p , "%s"  ,buf)；第一个参数是获取文件内容的指针，第二三个参数与scanf相同，fscanf不会读取行尾的’\n’,

——fgets会将行尾的’\n’读取到buf里面，用法：

int main() {

	
	FILE *p = fopen("D:\\temp\\a.txt", "r");//用读的方式打开一个文件
	while (!feof(p)) {//feof(p)如果已经到了文件结尾，函数返回真
		
		char s[1024] = { 0 };
		memset(s, 0, sizeof(s));
		fgets(s, sizeof(s), p);  //通过p读取文件内容赋值给s，第二个参数控制读取数据多少
		printf("%s", s);
	}
	fclose(p);//关闭这个文件
	return 0;
}

不论fprintf还是fputs都不会自动向行尾添加\n,需要代码中往buf的行尾写\n才可以达到换行的目录

#include

函数的第一个参数代表文件名，第二个参数是structstat结构。

得到文件的属性，包括文件建立时间，文件大小等信息。

函数设置文件指针stream的位置。如果执行成功，stream将指向以fromwhere为基准，偏移offset（指针偏移量）个字节的位置，函数返回0。如果执行失败则不改变stream指向的位置，函数返回一个非0值。

实验得出，超出文件末尾位置，还是返回0。往回偏移超出首位置，还是返回0，请小心使用。

第二个参数负数代表向前移动，整数代表向后移动。

第一个参数stream为文件指针

第二个参数offset为偏移量，单位：字节，正数表示正向偏移，负数表示负向偏移

第三个参数origin设定从文件的哪里开始偏移,可能取值为：SEEK_CUR、 SEEK_END 或 SEEK_SET

SEEK_SET： 文件开头

SEEK_CUR： 当前位置

SEEK_END： 文件结尾

函数ftell 用于得到文件位置指针当前位置相对于文件首的偏移字节数。在随机方式存取文件时，由于文件位置频繁的前后移动，程序不容易确定文件的当前位置。

fseek与ftell返回的是long类型，如果文件很大，超过long的范围，那么该函数会有问题，fgetpos与fsetpos函数可以处理更大的文件类型

返回值：成功返回0，否则返回非0

13.fread和fwrite函数
size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;
size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
注意：这 个函数以二进制形式对文件进行操作，不局限于文本文件
返回值：返回实际写入或读取的数据块数目
只要读取到文件最后，没有完整的读取一个数据块出来，fread就返回0
第一个参数代表void *，写入或者读取的缓冲区
第二个参数是代表写入或读取的时候最小单位的大小
第三个参数是代表写入或读取几个单位
第四个参数是FILE *

14.fread与feof

注意以下两段代码的区别

15.从一个文件读出数据，然后对其排序，又写入另一个文件：

#include 
#include 
#include 

void swap(int *a, int *b)//交换参数的值
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void pupple(int *p, int n)//冒泡排序
{
    int i;
    int j;
    for(i = 0; i p[j])
            {
                swap(&p[j - 1], &p[j]);
            }
        }
    }
}

int main(void)//在堆建立一个数组对文件内容进行排序
{
    int index = 0;//这是个计数器
    char buf[100];

    FILE *p = fopen("D:\\temp\\a.txt", "r");//第一次打开a.txt目的是要知道这个文件有多少行
    while(!feof(p))//如果没有到达文件结尾，那么循环继续,第一次循环的时候并不是要处理文件的内容，只是统计文件的行数
    {
        memset(buf, 0, sizeof(buf));//每次读取文件一行之前都把这个buffer清空
        fgets(buf, sizeof(buf), p);//从文件中读取一行
        index++;
    }
    fclose(p);

    int *array = calloc(sizeof(int), index);//在堆中建立一个动态数组，动态数组的成员数量和a.txt文件的行一样多

    p = fopen("D:\\temp\\a.txt", "r");
    index = 0;//计数器从0重新开始
    while(!feof(p))//如果没有到达文件结尾，那么循环继续
    {
        memset(buf, 0, sizeof(buf));//每次读取文件一行之前都把这个buffer清空
        fgets(buf, sizeof(buf), p);//从文件中读取一行
        array[index] = atoi(buf);//将读取到的一行转化为int，赋值给数组成员
        index++;
    }
    fclose(p);
    pupple(array, index);//将数组排序
    p = fopen("D:\\temp\\b.txt", "w");//用写的方式打开b.txt
    int i;
    for(i = 0; i 

c提高