C语言知识点保姆级总结，这不得进你的收藏夹吃灰？！
拖了很久的C语言所学知识的简单小结，内容有点多，第一次总结也可能有错误或者不全面，欢迎随时补充说明！

​ 用不同数据类型所定义的变量所占空间大小不一样，定义的变量不是保存于数据类型中，而是因为只有定义了该数据类型的变量才能保存数据。

​ 1、整型（int） 四字节，默认有符号（-2³¹-2³¹-1），无符号加unsigned（0-2³²-1）（十位数）;

​ 2、短整型（short int） ，两字节（-2¹⁵-2¹⁵-1）（五位数）;

​ 3、长整型（long int） ，四字节（同int，在目前的操作系统中几乎没有区别）;

​ 4、长长整型（long long int）， 八字节（-2⁶³-2⁶³-1），无符号（0-2⁶⁴-1）;

​ 1、单精度浮点数（float），四字节，保留小数点后6位

​ 2、双精度浮点数（double），八字节，保留小数点后15位

int为一个32为的存储单元，long long为64为的存储单元

1 B/byte（字节） = 8 bit（比特）（位）

1 KB（千字节） = 1024 B/byte（字节）

1 MB = 1024 KB

1 GB = 1024 MB

1TB =1024 GB

1 PB = 1024 TB

1 EB = 1024 PB

​ char，用于储存字符，和int很像，可用ASCII码来储存字符，
eg：

char grade=’A’;
 char grade=65;

'  '单引号为字符，eg：char a='a';

​ " "双引号为字符串，eg：char* a=“asd”;编译器会自动给字符串结尾添加’\0‘来作为字符结束标识，strlen函数中不统计\0，但是\0在内存中占据空间。

​ 除此之外，还有转义字符，通过反斜杠来完成相关操作,如果要特殊字符转字面字符需要另外添加反斜杠,转义字符在字符串中占空间，但是只计算一个长度，\0不计长度。

​

​ 作用域（scope），程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。

​ 生命周期：变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段

#includeint global = 2019;//全局变量
int main()
{
	int local = 2018;//局部变量
	return 0;
} 

​ 1、if语句

​ 语法结构：

if(表达式)
语句;

if(表达式){
	语句列表1
}
else{
	语句列表2；
}

//多分支
if(表达式1){
	语句列表1；
}
else if(表达式2){
	语句列表2；
}
else{
	语句列表3；
}

​ 表达式部分为真则执行语句（0为假，非0为真），尽量在每个分支语句后都加{}，否则只会执行分支后第一条语句。

​ else在没有括号的情况下遵循就近原则所以在多重if语句嵌套使用情况下一定要加括号！

​ 2、switch语句

​ switch作为分支结构常用于多分支的情况，可以简化多重if语句嵌套的情况。

​ 语法结构

switch(表达式A){
           case  常量表达式1:
                    语句1;
                    break;
           case  常量表达式2:
                    语句2;
                    break;
                    ……
           case  常量表达式n:
                    语句n;
                    break;
           default:
                    语句n+1; 
                     break;
}

​ 其中

​ 1、case后第一句不可定义变量，必须跟常量或者常量表达式，并且不可相同；

​ 2、break在语句中可以起到划分作用，不可省略，否则无法实现分支功能；

​ 3、default语句不应该省略，一般推荐位语句列表末尾；

​ 4、switch语句结束条件：①遇到break；②执行到语句列表末尾。

​ 1、while语句

​ 语法结构

while(表达式){
	循环语句；
}

​ 注：在循环语句中break的作用是停止后期所有循环，continue的作用是终止本次循环，开始下一次循环的判断。

​ 2、for语句

for(表达式1；表达式2；表达式3){
	循环语句；
}

​ 表达式1为初始化部分，用于初始化循环变量，当表达式1为空时直接进入循环；

​ 表达式2 为条件判断部分，用于判断循环是否终止，当表达式2为空时为死循环；

​ 表达式3为调整部分，用于循环条件的调整 。

​ 注：建议使用“前闭后开”来限定区间范围。

for(i=0; i<10; i++){
	a[i]=i;
}

​ 3、do while语句

do{
	循环语句；
}while(表达式);

​ 循环体至少执行一次，while之后记得加分号。

​ 二分查找函数循环实现范例：

int bin_search(int arr[], int left, int right, int key)
{
	int mid = 0;
	while(left<=right){
		mid = (left+right)>>1;
		if(arr[mid]>key)
		{
			right = mid-1;
		}
		else if(arr[mid]< key)
		{
			left = mid+1;
		}
		else
		{
			return mid;//找到了，返回下标
		}
	}
	return -1;//找不到
}

​ C语言基础库中的函数，在添加头文件后可直接调用。

​ 由函数名、返回值类型、函数参数以及函数体组成。

​ 实参：真实的传入函数的变量，**在被调用时会发生临时拷贝，并非把原来的变量直接放入函数中，**只是把实参的数据拷贝给形参。

​ 形参：函数名括号后的变量，因为形参只有在被调用的时候才被实例化并分配空间（形参实例化），**在被调用过后即被销毁，只在该函数中有效（局部变量），**所以叫形参。

​ 函数声明，要满足先声明后使用的原则，由返回值类型、函数名与函数参数组成（需要加分号）， 当我们用到很多函数声明的时候,为了方便我们的调用,我们可以创建一个头文件.h(比如test.h)，将函数声明放在头文件当中 ，在写头文件时,要注意加上#pragma once 。

//函数定义
double	Add(double x, double y){
	return x+y;
}
//函数声明
double 	Add(double x, double y);

​ 分为传值调用与传址调用，其中传址调用是把函数外部创建的内存地址传递给函数，可以真正与原值建立起联系，直接操纵函数外部的变量。

​ 函数也可以进行嵌套调用以及链式访问。

​ 嵌套调用样例：

#includevoid new_line()
{
	printf("hehe\n");
}
void three_line()
{
	int i = 0;
	for(i=0; i<3; i++)
	{
		new_line();
	}
}
int main()
{
	three_line();
	return 0;
}

​ 链式访问样例：

#include#includeint main()
{
	char arr[20] = "hello";
	int ret = strlen(strcat(arr,"bit"));
	printf("%d\n", ret);
	return 0;
}

​ 程序自身调用被称为递归，把复杂问题层层转化为与原问题类似的小问题，函数在调用自身的情况下存在不合法递归（即无限次的递归导致栈溢出）。

​ 所以在使用递归的时候一定要有递归出口，否则会陷入死循环导致栈溢出！

​ **注：**栈结构为电脑存储的一部分，从高地址处向下开辟存储空间，与用于开辟动态存储空间的堆相向开辟（堆为从低地址出向上开辟存储空间），而函数调用将会形成栈帧，函数返回后自动释放栈帧结构，在此过程中，该函数定义的所有局部变量都在该函数的栈帧内进行空间开辟。

样例：求n的阶乘

int factorial(int n)
{
	if(n<= 1)
		return 1;
	else
		return n* factorial(n-1);
}

​ 递归与迭代

​ 递归在使用过程中由于频繁进行函数调用，且每次调用都需要时间成本以及空间成本，所以递归程序简单，但是可能导致递归效率变低的问题，而迭代方案通过对变量值进行替换所以不会造成栈溢出，解决了效率低下的问题。

​ 样例（求斐波那契数列第n个的值）：

//递归实现
int fibrec(int n){
	if(n<=2) retuen 1;
	else return fibrec(n-1)+fibrec(n-2);
}
//迭代实现
int fibite(int n){
	int fir=1,sec=1,thd=2;
	if(n<=2) return 1;
	else{
		while(n>2){
			fir=sec;
			sec=thd;
			thd=fir+sec;
			n--;
		}
		return thd;
	}
}

​ 创建数组时数组空间为整体开辟整体释放，在内存中是连续存放，在定义时就已经确定数组大小（下标不可为0），且不可被整体赋值。在数组的创建过程中，如果进行了初始化则可不指定数组的大小，多维数组按照一维数组进行理解。

​ 数组传参发生降维，降维成指向其（数组）内部元素类型的指针。

​ 数组名一般情况下都指的是首元素的地址，但如果sizeof()单独出现以及&后跟数组名时表示的是整个数组

int s[5];
//表示数组首元素地址
printf("%d\n", sizeof(s+1));//结果为4/8，指针的具体大小根据编译器的不同大小不同
//表示整个数组
printf("%d\n", sizeof(s));//结果为20

​ 由于在传参过程中如果拷贝整个指针会导致效率大大降低甚至导致栈溢出，所以数组传参要发降维问题，函数内数组作为参数时，实参为首元素地址，形参为指针。

​ 在访问结构体成员时也同样要发生类似的操作，用指向结构体的指针来指代结构体。

typedef struct node{
 int a;
 int b;
}point;

void pop(int* p){
	
}

int main(){
	point a;
	int* p=a;
	pop(p);
	return 0;
}

​ 传参样例：

//用数组的形式传递参数，不需要指定参数的大小，传的只是数组首元素的地址。
void test(int arr[])
{}

//也可以传入数组大小
void test(int arr[10])
{}

//数组降维，用指针进行接收，传的是数组首元素的地址
void test(int *arr)
{}

//二维数组传参,第一个方括号可以空，但是第二个不可以空
void test(int arr[][5])
{}

void test(int arr[4][5])
{}

//传过去的是二维数组的数组名，即数组首元素的地址，也就是第一行的地址，第一行也是个数组，用一个数组指针接收(比较少用)
void test(int (*arr)[5])
{}

char a[]={'a','x','d'};
//此处由于结尾没有'\0'，strlen的机制是遇到'\0'即停止，所以在结尾没有'\0'时为随机数
//strlen(a)为随机数
//sizeof(a)为3

char a[]={'a','x','d'，'\0'};
//strlen(a)为3
//sizeof(a)为4

char* a="axd";//或char a[]="axd"
//直接通过""定义字符串时，会自动在结尾补'\0'，不需要自行补充，但'\0'依旧会占据一个字节
//strlen(a)为3
//sizeof(a)为4


char c[5]={'a', 'b', '\0', 'c', '\0'};
printf("%s", c);//结果为ab，因为字符串结束标志位'\0'

​ 注：①++/–高于解引用；

​ ②解引用高于±*/

​ ③±*/高于位运算；

​ ④位运算高于+=、-=、/=、*=；

%操作两边必须是整数。

与运算：&

​ 同1则1，否则为0；

或运算：|

​ 同0为0，否则为1

非运算：~

​ 1取0 0 取1

异或运算：^

​ 两者相等为0，不等为1

移位运算操作符：<< 左移 ； >>右移

​ ①**<<左移：**左边抛弃末尾补0；负数对反码的补码进行移位操作；相当于乘2；

​ ②**>>右移：有符号的补符号位**，无符号的补0；相当于除以2。

​ **反码：**正数的反码为原码本身，负数反码符号位不变，剩余的数字位取反；

​ **补码：**正数的补码为原码本身，负数的补码为反码+1 。

​ 隐式类型转换的原因：参与计算的数据如果类型不同无法直接进行计算。

​ 整型提升：有符号的补符号位，无符号的补0（符号位为最外面的那位）

​ 样例：

​ 例题，求循环次数

​ 解答：

​ unsigned char 8位数据位，范围在0-255，所以-2（11111110）时，变成254；同理-1（11111111）时，变成255；最后减到0时，不满足循环条件，for停止。刚好173次。 （7 4 1 ==>共(7-1)/3+1=3次，1-3=-2，即254，继续循环）
254 251 … 5 2 ==>共(254-2)/3+1=85次（2-3=-1，即255，继续循环）
255 252 … 6 3 ==>共(255-5)/3+1=85次（3-3=0，退出循环） 所以总共173次

​ 指针变量是个变量，指针本身是个地址，用于存放内存单元的地址。

​ 指针时用来存放地址的，指针类型的变量无论指向目标是什么类型，指针本身在32位平台所占大小都为4个字节，在64位平台是8个字节 。

#includeint main()
{
	int a = 10;//在内存中开辟一块空间，左值为空间，右值为内容
	int *p = &a；//type* p
				//这里我们对变量a，取出它的地址，可以使用&操作符。
				//将a的地址存放在p变量中，p就是一个之指针变量。
	return 0;
}

​ 1、对指针的解引用只能看到sizeof（type）个字节的数据；

​ 2、按字节为单位，数据有高权值和低权值之分，地址有低地址和高地址之分；

​ 3、数据低权值位在低地址处即为小端存储，反之则为大端存储。
（“小小小”）

​ 指向的位置是不可知的指针。

​ 1、指针在定义时就进行初始化；

​ 2、避免指针越界（eg：注意循环时循环次数的限制）；

​ 3、指针使用完即进行指针指向空间释放；

​ 4、避免返回局部变量的地址；

​ 5、指针使用前检查其有效性。

​ 1、指针±整数，等价于±sizeof（type）；

​ 2、指针-指针，两指针必须同一类型，一般用于数组与字符串求其两地址间相隔的单元格数，否则无效（指针+指针为非法操作）；

​ 3、指针的关系运算。

​ 4、指针和数组都可以用中括号或者解引用（二者互通）。

在指针的类型中我们知道有一种指针类型为字符指针 char* ;

一般使用方法

int main()
{
	char ch = 'w';
	char *pc = &ch;
	*pc = 'w';
	return 0;
}

用char*指针指向字符串

int main()
{
	const char* pstr = "hello bit.";
	printf("%s\n", pstr);
	return 0;
}
//上述代码中把字符串hello bit.的首地址放入了指针中

需注意字符串可以以字符数组的形式给出，但是此时的字符数组附有存储功能，而字符指针具有常量属性，指向的是常量区的内容，因此不可被修改，可以写作：

const char* str="hello world"；//从上图表示不可被修改

​ 也正因为这个原因 C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。

#includeint main()
{
	char str1[] = "hello world.";
	char str2[] = "hello world.";
	const char *str3 = "hello world.";
	const char *str4 = "hello world.";
	if(str1 ==str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");
	if(str3 ==str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");
	return 0;
}

​ 在此说一下const的一些知识点：

​ ① const修饰的变量不能被直接修改，但是可以通过指针在进行类型强转来修改（只是可以但是完全没必要）；

​ ② const修饰指针，表示不可以通过指针来修改所指目标；

​ ③ const能用则用，会很好的保护数据，

​ const的作用：

​ ① 写给编译器看，提前发现可能错误的修改；

​ ② 写给程序员看，提示该变量不建议修改。

const int* p=&a;
*p = 20; //错误，*p所指的值不可以修改
p = &n;//正确，*p的指向可以修改

int* const q = &m;
*q = 20;//正确，此时const修饰的是q，此时q所指向的值可以进行修改
q = &t;//错误，由于const修饰的是q，此时的q的指向不可以进行修改

const int a=10; //若const a=10，编译器也会默认为a是int类型的
int *P=(int*)&a; //注意需要强制&a前需要加int*类型强制类型转换(&a的原本类型为const int*)
*P=12;

指针数组本质上是数组，该类数组内存放的的元素是指针。

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

指针数组本质上是指针，该类指针指向的是一个数组。

example：

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针

首先需要看的是数组名与&数组名（可以等价于数组指针）之间的关系

#includeint main()
{
	int arr[10] = { 0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	printf("arr+1 = %p\n", arr+1);
	printf("&arr+1= %p\n", &arr+1);
	return 0;
}

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

数组传参会发生降维，最终传入的是首元素的地址（指针），并利用此来访问数组内其他元素。

#includevoid test(int arr[])//ok
{}
void test(int arr[10])//ok
{}
void test(int *arr)//ok
{}
void test2(int *arr[20])//不ok
{}
void test2(int **arr)//不ok
{}
int main()
{
	int arr[10] = {0};
	int *arr2[20] = {0};
	test(arr);
	test2(arr2);
}

二维数组传参，函数形参的设计只能省略第一个[]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。

void test(int arr[3][5])//ok
{}
void test(int arr[][])//不ok
{}
void test(int arr[][5])//ok
{}
void test(int *arr)//不ok
{}
void test(int (*arr)[5])//ok
{}
void test(int* arr[5])//不ok
{}
void test(int **arr)//ok
{}
int main()
{
	int arr[3][5] = {0};
	test(arr);
}

需要传入一个地址

#includevoid print(int *p, int size)
{
	int i = 0;
	for(i=0; i

#includevoid test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int*p = &n;
	int **pp = &p;
	test(pp);
	test(&p);
	return 0;
}

Type (*pFunc)(datatype args);

    //pFunc为函数指针，Type为数据类型，参数（datatype args）可以有多个，也可以没有。

bool max(int a, int b)
{
	if (a>b)
	{
		return a;
	}else{
		return b;
	}
}
 
void Test()
{
	bool (*pFunc)(int, double);
	pFunc = max;
	cout<< max(5, 10)<< endl;
}

作者：no.body
链接：https://www.zhihu.com/question/19801131/answer/27459821
来源：知乎
//大佬在这个帖子里对于概念解释的很好，可以做参考！

struct node1{
	int  a;
	int  b;
};

typedef struct node2 {
	int c;
	int d;
}node2;//通过typedef为结构体变量定义一个别名node2，在以后使用中可以使用别名以此提高编写效率

int main(){
	struct node1 s;//用结构体定义变量
	node2  q;//用别名定义变量
}

struct Node
{
	int data;
	struct Node next;
};//错误

struct Node
{
	int data;
	struct Node* next;
};//正确

typedef struct Node
{
	int data;
	struct Node* next;
}Node;//正确

struct Point1
{
	int x;
	int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2

typedef struct Point2
{
	int x;
	int y;
}p;
p p1;
p p2;

typedef struct Point2
{
	int x;
	int y;
}p;
p p1;
p1.x=1;
p1.y=2;//可以直接用结构体类型的变量进行定义

typedef struct Point2
{
	int x;
	int y;
}p;
p* p2=(p*)malloc(sizeof(p));
p2->x=1;
p2->y=2;//定义一个指向结构体的指针并为其分配空间即可进行定义

struct S1
{
    char a;
    int b;
    char C;
};
printf("%d\n", sizeof(struct S1));

#pragma pack(a)//通过该指令可设置默认对齐数为a

struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun   //最后一个不加逗号
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
}；

//联合类型的声明
union Un
{
	char c;
	int i;
};
//联合变量的定义
union Un un;

void* malloc (size_t size);

void* calloc (size_t num, size_t size);

void* realloc (void* ptr, size_t size);

int* ptr = (int*)malloc(100);
int* p = NULL;
p = realloc(ptr, 1000);
if (p = !NULL) {
	ptr = p;
}

int* p=(int*)malloc(100);
......
free(p);
p = NULL;

typedef struct st_type
{
	int i;
	int a[0];//柔性数组成员
}type_a;
printf("%d\n", sizeof(type_a));//输出的是4
//初始化
type_a *p = (type_a*)malloc(sizeof(type_a)+100*sizeof(int));
p->i = 100;
for(i=0; i<100; i++)
{
	p->a[i] = i;
}
free(p);