第一章：C语言基础总结

C语言基础总结，不对的请指正，谢谢。

#include<stdio.h>
int main()
{

	printf("HelloWorld!");
	return 0;
}
//变量是计算机中一块特定的内存空间。 
	//变量：一个数据存储空间的表示
	//不同数据存入具有不同内存地址的空间，相互独立。
//变量的命名规则
	//变量名只能由字母、数字和下划线3种字符组成
	//第一个字符必须是字母或者下划线
	//不能使保留字/关键字
//数据类型
	//数值类型-整型：int（整型），short（短整型），long（长整型）。
	//数值类型-非整形（浮点型）：float（单精度浮点型），double（双精度浮点型）。
	//非数值（字符类型）：char

//C语言常用数据类型
	//整型    		int         32位      -2147483648~ +2147483647	
	//短整型  		short int   16位      -32767~+32768
	//长整型  		long int    32位      -2147483648~ +2147483647
	//单精度浮点型  float       32位      -3.4E-38~+3.4E+38
	//双精度浮点型  double      64位      -1.7E-308~1.7E+308
	//字符型        char        8位       -128~+127
	
//数据类型   变量
	//数据类型：用来规定变量的内存空间有多大
	//变量名命名规则：
					  1.首字母：下划线“_”和普通字母
					  2.其他字母：下划线“_”、普通字母和数字
					  3.不能是关键字
//位运算符中：  “比较时，数字要转为二进制”
    //     &       按位与              两个操作数同时为1时结果为1
	//	   |       按位或              两个操作数只要有一个为1，结果就为1
	//     ~       按位非              操作数为1，结果为0；操作数为0，结果为1
	//     ^	   按位异或            两个操作数相同，结果为0；不相同结果为1
	//     <<      左移                右侧空位补0
	//     >>      右移                左侧空位补符号位
	//     >>>     无符号右移          左侧空位补0
//sizeof运算符
	//使用sizeof运算符可以获得数据类型占用内存空间的大小
	//基本用法：sizeof（type name）
	//结果以字节为单位
//运算符优先级       （由下至上优先级增加）
	//    （）   sizeof   ++    --
	//     !
	//     算数运算符
	//     关系运算符
	//     &&
	//     ||
	//     赋值运算符
//switch结构                                                          //使用switch结构使得注意点  
	//		switch（表达式）										  		//switch后的表达式只能是整型或字符型
	//		{														  		//case后常量表达式的值不能相同
	//		case 常量1：													//case后允许许多条语句，不需要大括号
	//		     语句1；													//如果不添加break语句，需要特别注意执行顺序
	//			 break；													//case和default子句的先后顺序可以自行变动
	//		case 常量2：													//default子句可以省略
	//			 语句2；															
	//			 break；														
	//		......														
	//		default:													
	//			 语句；     //（不在上述case范围内）
	//		}
//while循环                                                //循环三要素：                                      //while循环特点：先判断，再执行
	//while(循环条件)                                      //1、循环变量的初值
	//{													   //2、循环变量的判断
	//循环操作语句										   //3、循环变量的更新
	//}
//使用codeblocks调试c程序
	//步骤：
		1、分析错误
		2、设置断点
		3、启动调试
		4、单步运行
		5、观察变量
		6、发现问题
		7、修正代码重新运行	
//do-while循环
	//基本语法：											//特点：先执行，再判断
		{do														//	先执行一遍循环操作
		循环操作												//符合条件，循环继续执行
		}while（循环条件）；									//否则循环退出
//while循环和do-while循环区别
	//执行顺序不同
	//初始情况不满足循环条件时
		//while循环一次都不会执行
		//do-while循环不管任何情况都至少执行一次
//调试：确保路径里面没有中文以及特殊符号
//for循环
	//语法
		for(表达式1;表达式2;表达式3)						//表达式1，通常是为循环变量赋初值，可以省略。 
		{													//表达式2，循环条件，是否继续执行循环，可以省略。
			语句;											//表达式3，更新循环变量的值，可以省略。
		}													//分号，用来分隔三个表达式，不可以省略！    for(;;)是死循环。
//for循环常见问题
	//忘记定义循环变量或初始化
	//循环条件缺少时会造成死循环
	//循环变量不更新也会造成死循环
	//不可省略分号
//break语句的作用                               //break能跳出switch语句也能跳出循环语句（for;while;do-while）;当for循环语句中存在break，则最后的++或者--都不会执行。
	//跳出循环，执行循环之后的语句(跳出整个循环)
//continue语句
	//continue语句的作用
		//跳过本次循环，继续下次循环
			//////////////////////////////////
				while(循环语句)					
				{......
				continue;    //跳到循环条件去
				 ......
				}
			//////////////////////////////////	
				do 
				{......
				continue;    //跳到循环条件去
				 ......
				}while(循环条件)
			//////////////////////////////////
				for(;循环条件;更新循环变量;)
				{......
				continue;    //跳到更新循环变量去
				 ......
				}
//break和continue的区别：
	//使用场合
		//break可用在switch结构和循环结构中
		//continue只能用在循环结构中
	//作用（循环结构中）
		//break语句用于终止某个循环，程序跳转到循环块外的下一条语句
		//continue跳出本次循环，进入下一次循环
//循环结构总结
	//相同点
		//多次重复执行一个或多个任务时考虑使用循环来解决问题
	//区别
		//除了语法不同，判断和执行顺序也不同
		//适用情况不同
			//循环次数确定的情况下，通常选用for循环
			//循环次数不确定的情况时，通常选用while和do-while循环
//数组             
	//数组是一个变量，由数据类型相同的一组元素组成
			//数组与变量之间的区别：变量是内存中的一块空间；	数组是内存中一串连续的空间（连续的内存空间）。
	//数组的结构和基本要素
		//标识符：数组的名称，用于区分不同的数组
		//数组元素：向数组中存放的数据
		//元素下标：对数组元素进行编号
		//元素类型：数组元素的数据类型     （强调：数组中的所有元素必须属于相同的数据类型）
		
		//数组只有一个名称，即标识符（用来表示数组的变量名）
		//元素下标标明了元素在数组中的位置，从0开始
		//数组中每个元素都可以通过下标来访问
		//数组长度固定不变，避免数组越界
	//数组的语法：datatype arrayName[size];
		//例1：
			int nums[25];
			char array_of_name[30];
			double curr_salary[35];
		//例2：
			#define N 50
			int emp_id[N];
			......
			const int SIZE = 100;
			double prices[SIZE];
//数组总结
	//数组是可以在内存中连续存储多个元素的结构
		//数组中的所有元素必须属于相同的类型
	//数组必须先声明，然后才能使用
		//声明一个数组只是为该数组留出内存空间，并不会为其赋任何值
	//数组的元素通过数组下标访问
	//一维数组可以用一个循环动态初始化，而二维数组可以用	嵌套循环动态初始化
	//二维数组可以看做是由一维数组的嵌套而构成的
//二维数组
	//语法；
		//datatype name[rowSize][colSize]
		//double score[5][3]
		//int animate[4][4]
	
	

//指针（pointer）简介
	//指针是一个值为内存地址的变量（或数据对象）（内存地址一般使用16进制表示）
//指针的基本用法
	//数据类型*指针变量名;
	//例如：
			int*ptr_num;
			char*ptr_name;
			float*money_ptr;
			double*p_price;
	//注意：在头文件<stdio.h>中，NULL被定义为常量（它表示0）
			int*ptr_num=NULL;
			指针的初值设置为空，表示指针不指向任何地址
	
//指针小节
	//指针同样是一个变量，只不过该变量中存储的是另一个对象的内存地址
	//如果一个变量存储另一个对象的地址，则称该变量指向这个对象
	//指针变量可以赋值，指针的指向在程序中可以改变
		//指针p在执行中某时刻指向变量x，在另一时刻也可以指向y
	//注意：
		（1）指针变量的命令规则和其他变量的命名规则一样
		（2）指针不能与现有变量同名
		（3）指针可以存放C语言中任何数据基本类型、数组和其他所有高级数据结构的地址
		（4）若指针已声明为指向某种类型数据的地址，则它不能用于存储其他类型数据的地址（例如：int型指针里面不能存放double型数据）
		（5）应为指针指定一个地址后，才能在语句中使用指针
		
//指针与数组
	//数组（数组首地址和数组首元素地址一样；数组名就是数组首元素地址）
		//存储在一块连续的内存空间中
		//数组名就是这块连续内存空间的首地址
	//指针的算术运算
		//指针的递增和递减（++，--）		注意：一个类型为T的指针的移动，以sizeof(T)为移动单位
	//数组名就是这块连续内存单元的首地址
		//int num[50];//num是数组名，也是数组的首地址
		//num的值与&num[0]的值是相同的
		//数组第i + 1个元素可表示为：
			//第i + 1个元素的地址：&num[i+1]或num + i
			//第i + 1个元素的值：num[i+1]或*(num + i)
		//为指向数组的指针赋值：
			//int * ptr_num = num;或int * ptr_num = &num[0]
		//指针变量可以指向数组元素
			//int * ptr_num = &num[4];或int * ptr_num = num + 4;
//二维数组与指针
	//如：5行3列的二位数组
	//首地址：&a[0][0]     也是认为数组的数组名
	//使用指针访问二维数组中元素
		//*(a[1]+2)
		//*(*(a+1)+2)					num[i][j]等价于*(*(num + i) + j)   二维数组  重点！！！！！！！！！！！！            num[i]等价于*(num + i)		一维数组
//指针总结
	//指针是一个变量，存储另一个变量（对象）的内存地址        （指针不可以赋常量）
	//指针的声明由基本类型、星号（*）和变量名组成
	//为指针赋值，赋值运算符右侧不许是一个地址
		//如果是普通变量需要在前面加一个取地址运算符&
		//如果是另一个指针变量或者是一个数组，不需要加&运算符
	//运算符*用于返回指针指向的内存地址中存储的值
	//使用指针访问一维数组和二维数组的元素
	//指针和字符串
	
	
//函数（function）
	//是完成特定任务的独立程序代码
	//语法规则定义了函数的结构和使用方法
//为什么要使用函数
	//可以省去编写重复代码的苦闷
	//可以让程序更加模块化，提高代码可读性
	//方便后期修改，完善
//函数的种类
	//内置函数
		//由C语言系统提供
		//需要在程序前包含定义函数的头文件
	//自定义函数
		//不带参数
		//带参数
//内置函数补充：malloc和calloc
	//malloc动态分配内存：为指针分配5个元素的空间
		#include <stdio.h>
		#include <stdlib.h>
		void main()
		{
			int * num;
			int i;
			num = (int *)malloc(sizeof(int) * 5);//malloc需要强制转换
			num[4] = 9;
			for (i=0;i<5;i++)
			{
				printf("%d\n",num[i]);
			}
			free(num);//用完释放内存
		}
	//calloc和malloc类似。1：不需要强转，直接返回数组；2：两个参数，默认初始化数组元素。
	//calloc使用:为指针分配5个元素的空间
		#include <stdio.h>
		#include <stdlib.h>
		void main()
		{
			int * num;
			int i;
			num = calloc(5,sizeof(int));//calloc不需要强制转换
			num[4] = 9;
			for (i=0;i<5;i++)
			{
				printf("%d\n",num[i]);
			}
			free(num);//用完释放内存
		}
	//关于以上的free函数：
		1、必须是通过malloc、calloc和realloc(重新分配内存)分配内存的指针
		2、释放的指针必须是初始分配的地址，进行运算后需要恢复
//自定义函数
	//函数定义
		return_type function_name([datatype1 arg1],[datatype2 arg2],[...])
		{
		//函数体
		}
	//函数三要素
		//返回值类型
		//函数名
		//参数列表
	//自定义函数的完整写法		注意1：函数原型与函数定义的头部类似，最后以分号结尾；注意2：函数原型中的参数名称可以省略，只写参数类型。
		#include <stdio>
		//函数原型
		int sum(int,int);
		int main()
		{
			...
		}
		//函数定义
		int sum(int num1,int num2)
		{
			//函数实现的代码
		}
	//C语言中的返回值
		//关键字：return
		//只能返回一个值，不能返回多个值
		//返回值类型必须与原型中的返回值类型匹配
		//return会立即终止函数，并返回
//递归
	//函数点用自己的过程叫做递归	（递归所实现的业务逻辑大部分是可以通过循环来实现的）
	
///////C语言进阶///////		变量的作用域和生存周期；变量的两种传递方式；使用带参函数解决实际问题；使用数组作为函数参数；使用头文件。

//变量的作用域和生存周期
	//注意1：变量只存在于定义它们的语句块中；
	//变量在一个块内声明时创建，在这个块结束时销毁-自动变量
	//变量存在的时间就是变量的生存期
//小结
	//变量的作用域：
		//全局、局部
	//变量的生存周期
		//变量的存储方式：动态存储（自动、寄存器）、静态存储（静态和外部）
		//由变量的存储方式不同而产生的特性称为变量的生存期（变量的存在时间）
		//基本类型的静态变量系统默认赋初值为0
		//静态变量的生存期是整个源程序，作用域只是定义它的文件
		//函数被调用时，其中的局部静态变量的值保留前次被调用的结果
	//按值传递的机制
		//给函数传递变元（参数）时，变元（参数）值不会直接传递给参数，而是先制作变元（参数）值的副本，存储在栈上，再使这个副本可用于函数，而不是使用初始值。
	
	//使用数组作为函数参数时1
		//1、数组作为函数实参时，只传递数组的地址（首地址），并不传递整个数组空间
		//2、当用数组名作为实参调用函数时，数组首地址指针被传递到函数中
																									//	/*
																									//	量数组大小：
																									//	double test[] = {1,2,3,4,5,6};
																									//	printf("test数组的元素的个数：%d\n",sizeof(test)/sizeof(test[0]));
																									//	*/
	//使用头文件
		//自定义头文件
			//一般放一些重复使用的代码，例如函数声明、变量声明、常量声明、宏的定义等。
//函数总结
	//根据变量的作用域可以将变量划分为：局部变量和全局变量
	//根据变量的存储类型（决定生存周期）将变量划分为：自动变量、寄存器变量、静态变量、外部变量
		//静态局部变量的生存周期为整个源程序，但其作用域为定义该变量的函数
		//静态全局变量的生存周期为整个源程序，其作用域为定义该变量的源文件
	//传值调用，在被调函数中改变形参值，只是改变其副本值，而不会影响调用函数中实参值
	//采用传址调用方式时，传递的是变量的地址值，这样在被调函数中，对形参的操作实际上操作的是实参本身
	//数组作为参数传递时，实际采用传址方式
	
//字符串
	//字符串
		//1、一个或多个字符的序列
		//2、C语言中形如“My heart is still”
		//3、双引号不是字符串的一部分，仅用来告知编译器括起来的是字符串
	//C语言中的字符串
		//使用字符数组存储：每个存储单元占一个字节，结尾是空字符 \0
//小结
	//字符串由一个或多个字符的序列称为字符串
	//C语言中使用字符数组存储字符串
	//所有的字符串都是字符数组，反之不成立
	//三种方式录入字符串
		//1、scanf("%s",str);
		//2、gets(str);
		//3、fgets(str,50,stdin);
//指向字符串的指针
	//将指针指向字符串
		//可以指向常量字符串
		//也可以指向存储字符串的字符数组
//数组和指针
	//初始化字符数组时会把静态存储区的字符串拷贝到数组中
	//初始化指针时只把字符串的地址拷贝给指针
	
//结构
	//结构是一种构造数据类型
	//注意：1、结构定义并不预留内存。2、结构定义一般放在程序的开始部分（头文件声明之后）。3、结构定义仅用来描述结构的形式，使用结构需要声明结构变量
//指向结构的指针
	//一个指针指向结构时，称为结构指针变量
	//结构指针变量中的值是所指向的结构变量的首地址
	//一般形式：struct 结构名称 *结构指针变量名;
	//访问结构成员的一般方式：
		//1、(*结构指针变量).成员变量名
		//2、结构指针变量 -> 成员变量名
//参数传递小结
	//1、传递结构成员
	//2、传递结构
		//优点：函数处理的是原始数据的副本，保护了原始数据
		//缺点：老版本不支持；传递结构浪费时间和空间
		//一般用来处理小型结构数据
	//3、传递结构的地址
		//优点：程序的执行速度快，效率高
		//缺点：无法保护数据，函数中操作有可能会意外影响原结构中的数据
		//程序员为了追求效率，常用此方案
//总结
	//结构是由若干数据项组合而成的复杂数据对象，这些数据项称为结构的成员
	//要在程序里使用结构，需要声明结构变量
	//访问结构成员的操作要用圆点运算符（.）
		//一把形式为：结构变量名.成员名
	//可以通过只想结构的指针访问结构成员
		//常见形式为：结构指针变量->成员名。
	//数组元素的类型为结构的数组称为结构数组
	//结构作为函数参数有三种不同的形式：
		//结构成员的值传递给函数参数、整个结构作为参数传递、结构指针变量做函数的参数
//