C提高笔记（1）：数据类型、内存分区、指针

1.数据类型

1.1数据类型是为了更好进行内存的管理,让编译器能确定分配多少内存，数据类型可以理解为创建变量的模具: 固定大小内存的别名。
1.2
占用内存空间字节：(32位机）
char（1） short（2） int（4） long（4）float（4）double（8）

void 数字类型修饰函数参数和函数返回，可以指向任何类型的数据，用于数据类型的封装。
sizeof告诉我们编译器为某一特定数据或者某一个类型的数据在内存中分配空间时分配的大小，大小以字节为单位，sizeof返回的数据结果类型是unsigned int。
可以给已存在的数据类型起别名typedef。

2.变量

既能读又能写的内存对象，称为变量；若一旦初始化后不能修改的对象则称为常量。变量定义形式： 类型 标识符, 标识符, …
变量名的本质：一段连续内存空间的别名。通过变量名访问内存空间

3.程序的内存分区

3.1运行前

程序编译步骤：
1）预处理：宏定义展开、头文件展开、条件编译，这里并不会检查语法
2）编译：检查语法，将预处理后文件编译生成汇编文件
3）汇编：将汇编文件生成目标文件(二进制文件)
4）链接：将目标文件链接为可执行程序

程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区（text）、数据区（data）和未初始化数据区（bss）：
代码区
存放 CPU 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。
全局初始化数据区/静态数据区（data段）
该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和t）和常量数据（如字符串常量）。
未初始化数据区（bss 区）
存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或（NULL）。

为什么把程序的指令和程序数据分开：

• 程序被load到内存中之后，可以将数据和代码分别映射到两个内存区域。由于数据区域对进程来说是可读可写的，而指令区域对程序来说是只读的，所以分区之后可以将程序指令区域和数据区域分别设置成只读和可读可写。这样可以防止程序的指令有意或者无意被修改；
• 当系统中运行着多个同样的程序的时候，这些程序执行的指令都是一样的，所以只需要内存中保存一份程序的指令就可以了，只是每一个程序运行中数据不一样而已，这样可以节省大量的内存。比如说之前的Windows Internet Explorer 7.0运行起来之后， 它需要占用112 844KB的内存，它的私有部分数据有大概15 944KB，也就是说有96 900KB空间是共享的，如果程序中运行了几百个这样的进程，可以想象共享的方法可以节省大量的内存。

3.2运行后

程序在加载到内存前，代码区和数据区的大小就是固定的，程序运行期间不能改变。运行可执行程序，操作系统把物理硬盘程序load(加载)到内存，除了根据可执行程序的信息分出代码区（text）、数据区（data）和未初始化数据区（bss）之外，还额外增加了栈区、堆区：
代码区（text segment）
加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。
未初始化数据区（BSS）
加载的是可执行文件BSS段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化，静态未初始化数据）的生存周期为整个程序运行过程。
全局初始化数据区/静态数据区（data segment）
加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量(只读)）的数据的生存周期为整个程序运行过程。
栈区（stack）
栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。
堆区（heap）
堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

3.3 分区

栈区：由系统进行内存的管理。主要存放函数的参数以及局部变量。在函数完成执行，系统自行释放栈区内存，不需要用户管理。
堆区：由编程人员手动申请，手动释放，若不手动释放，程序结束后由系统回收，生命周期是整个程序运行期间。使用malloc或者new进行堆的申请。
堆分配内存API：
#include <stdlib.h>
void *calloc(size_t nmemb, size_t size);
功能：在内存动态存储区中分配nmemb块长度为size字节的连续区域。calloc自动将分配的内存置0。
参数： nmemb：所需内存单元数量
size：每个内存单元的大小（单位：字节）
返回值：成功：分配空间的起始地址
失败：NULL

#include <stdlib.h>
void *realloc(void *ptr, size_t size);
功能：重新分配用malloc或者calloc函数在堆中分配内存空间的大小。realloc不会自动清理增加的内存，需要手动清理，如果指定的地址后面有连续的空间，那么就会在已有地址基础上增加内存，如果指定的地址后面没有空间，那么realloc会重新分配新的连续内存，把旧内存的值拷贝到新内存，同时释放旧内存。
参数：ptr：为之前用malloc或者calloc分配的内存地址，如果此参数等于NULL，那么和realloc与malloc功能一致
size：为重新分配内存的大小, 单位：字节
返回值：成功：新分配的堆内存地址
失败：NULL

全局/静态区：全局静态区内的变量在编译阶段已经分配好内存空间并初始化。这块内存在程序运行期间一直存在，主要存储全局变量、静态变量和常量。
注意：
（1）这里不区分初始化和未初始化的数据区，是因为静态存储区内的变量若不显示初始化，则编译器会自动以默认的方式进行初始化，即静态存储区内不存在未初始化的变量。
（2）全局静态存储区内的常量分为常变量和字符串常量，一经初始化，不可修改。静态存储内的常变量是全局变量，与局部常变量不同，区别在于局部常变量存放于栈，实际可间接通过指针或者引用进行修改，而全局常变量存放于静态常量区则不可以间接修改。
（3）字符串常量存储在全局/静态存储区的常量区。
C/C++内存分区其实只有两个，即代码区和数据区：
代码区：存放程序编译后的二进制代码，不可寻址区
数据区包括：堆，栈，全局/静态存储区
全局/静态存储区包括：常量区，全局区、静态区
常量区包括：字符串常量区、常变量区。

3.4 函数调用

栈保存一个函数调用所需要维护的信息，通常被称为堆栈帧(Stack Frame)或者活动记录(Activate Record)。一个函数调用过程所需要的信息一般包括函数的返回地址；函数的参数；临时变量；保存的上下文：包括在函数调用前后需要保持不变的寄存器。

调用惯例：函数的调用方和被调用方对于函数是如何调用的必须有一个明确的约定，只有双方都遵循同样的约定，函数才能够被正确的调用。一个调用惯例一般包含一个调用惯例一般包含、栈的维护方式。

调用惯例	出栈方	参数传递	名字修饰
cdecl	函数调用方	从右至左参数入栈	下划线+函数名
stdcall	函数本身	从右至左参数入栈	下划线+函数名+@+参数字节数
fastcall	函数本身	前两个参数由寄存器传递，其余参数通过堆栈传递	@+函数名+@+参数的字节数
pascal	函数本身	从左至右参数入栈	较为复杂，参见相关文档
栈的生长方向和内存存放方向：

4.指针

指针是一种数据类型，占用内存空间，用来保存内存地址，也可以被赋值。空指针不指向任何东西，不允许向NULL和非法地址拷贝内存。野指针指向一个已删除的对象或未申请访问受限内存区域的指针，指针变量初始化时置 NULL，释放时置 NULL。

间接访问操作符

通过一个指针访问它所指向的地址的过程叫做间接访问，或者叫解引用指针，这个用于执行间接访问的操作符是*。
在指针声明时，* 号表示所声明的变量为指针
在指针使用时，* 号表示操作指针所指向的内存空间
1）* 相当通过地址(指针变量的值)找到指针指向的内存，再操作内存
2）* 放在等号的左边赋值（给内存赋值，写内存）
3）* 放在等号的右边取值（从内存中取值，读内存）
间接赋值：通过指针间接赋值成立的三大条件：
1）2个变量（一个普通变量一个指针变量、或者一个实参一个形参）
2）建立关系
3）通过 * 操作指针指向的内存
指针做函数参数，具备输入和输出特性：
输入：主调函数分配内存
输出：被调用函数分配内存

字符串指针

字符串指针做函数参数:

//字符串基本操作
//字符串是以0或者'\0'结尾的字符数组，(数字0和字符'\0'等价)
void test01(){
	//字符数组只能初始化5个字符，当输出的时候，从开始位置直到找到0结束
	char str1[] = { 'h', 'e', 'l', 'l', 'o' };
	printf("%s\n",str1);
	//字符数组部分初始化，剩余填0
	char str2[100] = { 'h', 'e', 'l', 'l', 'o' };
	printf("%s\n", str2);
	//如果以字符串初始化，那么编译器默认会在字符串尾部添加'\0'
	char str3[] = "hello";
	printf("%s\n",str3);
	printf("sizeof str:%d\n",sizeof(str3));
	printf("strlen str:%d\n",strlen(str3));
	//sizeof计算数组大小，数组包含'\0'字符
	//strlen计算字符串的长度，到'\0'结束
	//那么如果我这么写,结果是多少呢？
	char str4[100] = "hello";
	printf("sizeof str:%d\n", sizeof(str4));//100
	printf("strlen str:%d\n", strlen(str4));//5
	//请问下面输入结果是多少？sizeof结果是多少？strlen结果是多少？
	char str5[] = "hello\0world"; 
	printf("%s\n",str5);  //hello
	printf("sizeof str5:%d\n",sizeof(str5)); //12
	printf("strlen str5:%d\n",strlen(str5)); //5
	//再请问下面输入结果是多少？sizeof结果是多少？strlen结果是多少？
	char str6[] = "hello\012world";
	printf("%s\n", str6);//hello 
                         //world
    printf("sizeof str6:%d\n", sizeof(str6)); //12 (/012相当于回车键，占一个字符)
	printf("strlen str6:%d\n", strlen(str6)); //11
}

字符串的格式化：sprintf

#include <stdio.h>
int sprintf(char *str, const char *format, ...);
功能：
     根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符 '\0'  为止。
参数： 
	str：字符串首地址
	format：字符串格式，用法和printf()一样
返回值：
	成功：实际格式化的字符个数
	失败： - 1

sscanf

 #include <stdio.h>
int sscanf(const char *str, const char *format, ...);
功能：
    从str指定的字符串读取数据，并根据参数format字符串来转换并格式化数据。
参数：
	str：指定的字符串首地址
	format：字符串格式，用法和scanf()一样
返回值：
	成功：成功则返回参数数目，失败则返回-1
	失败： - 1
	格式	作用
%*s或%*d	跳过数据
%[width]s	读指定宽度的数据
%[a-z]	匹配a到z中任意字符(尽可能多的匹配)
%[aBc]	匹配a、B、c中一员，贪婪性
%[^a] 	匹配非a的任意字符，贪婪性
%[^a-z]	表示读取除a-z以外的所有字符

一级指针易错点

越界
void test(){
	char buf[3] = "abc";
	printf("buf:%s\n",buf);
}

const使用
//const修饰变量
void test01(){
	//1. const基本概念
	const int i = 0;
	//i = 100; //错误，只读变量初始化之后不能修改
	//2. 定义const变量最好初始化
	const int j;
	//j = 100; //错误，不能再次赋值
	//3. c语言的const是一个只读变量，并不是一个常量，可通过指针间接修改
	const int k = 10;
	//k = 100; //错误，不可直接修改，我们可通过指针间接修改
	printf("k:%d\n", k);
	int* p = &k;
	*p = 100;
	printf("k:%d\n", k);
}

//const 修饰指针
void test02(){
	int a = 10;
	int b = 20;
	//const放在*号左侧 修饰p_a指针指向的内存空间不能修改,但可修改指针的指向
	const int* p_a = &a;
	//*p_a = 100; //不可修改指针指向的内存空间
	p_a = &b; //可修改指针的指向
	//const放在*号的右侧, 修饰指针的指向不能修改，但是可修改指针指向的内存空间
	int* const p_b = &a;
	//p_b = &b; //不可修改指针的指向
	*p_b = 100; //可修改指针指向的内存空间
	//指针的指向和指针指向的内存空间都不能修改
	const int* const p_c = &a;
}
//const指针用法
struct Person{
	char name[64];
	int id;
	int age;
	int score;
};

//每次都对对象进行拷贝，效率低，应该用指针
void printPersonByValue(struct Person person){
	printf("Name:%s\n", person.name);
	printf("Name:%d\n", person.id);
	printf("Name:%d\n", person.age);
	printf("Name:%d\n", person.score);
}

//但是用指针会有副作用，可能会不小心修改原数据
void printPersonByPointer(const struct Person *person){
	printf("Name:%s\n", person->name);
	printf("Name:%d\n", person->id);
	printf("Name:%d\n", person->age);
	printf("Name:%d\n", person->score);
}
void test03(){
	struct Person p = { "Obama", 1101, 23, 87 };
	//printPersonByValue(p);
	printPersonByPointer(&p);
}

指针的指针

二级指针做参数的输出特性是指由被调函数分配内存

//分配内存
void allocate_memory(char*** p, int n){
	if (n < 0){
		return;
	}
	char** temp = (char**)malloc(sizeof(char*)* n);
	if (temp == NULL){
		return;
	}

	//分别给每一个指针malloc分配内存
	for (int i = 0; i < n; i++){
		temp[i] = malloc(sizeof(char)* 30);
		sprintf(temp[i], "%2d_hello world!", i + 1);
	}
	*p = temp;
}

//打印数组
void array_print(char** arr, int len){
	for (int i = 0; i < len; i++){
		printf("%s\n", arr[i]);
	}
	printf("----------------------\n");
}

//释放内存
void free_memory(char*** buf, int len){
	if (buf == NULL){
		return;
	}
	char** temp = *buf;
	for (int i = 0; i < len; i++){
		free(temp[i]);
		temp[i] = NULL;
	}
	free(temp);
}

void test(){
	int n = 10;
	char** p = NULL;
	allocate_memory(&p, n);
	//打印数组
	array_print(p, n);
	//释放内存
	free_memory(&p, n);
}