【C语言】C语言入门知识

	C语言的主函数是main()函数，有且仅有一个。
	例如：
	int main()
	{
	
		return 0;
	}
	是一个标准的C语言主函数。

	C语言中的输出函数为printf，输入函数为scanf，使用前需要引用头文件#include <stdio.h>。
	例如：
	int main()
	{
		int a = 0;
		printf("hello,bit!");	
		scanf("%d",&a);	          //在vs使用scanf函数需要引用#define _CRT_SECURE_NO_WARNINGS 1
		return 0;
	}
	这就是printf函数的用法

	char                 //字符数据类型
	short                //短整型
	int                  //整型
	long                 //长整型
	long long            //更长的整型
	float                //单精度浮点数
	double               //双精度浮点数

	（1）计算机中能够识别的是二进制，在二进制中，只有0和1，而每个0或者1就是一个比特位。
	（2）C语言中的常见单位（从小到大）：
	bit(比特)<byte(字节)<KB<MB<GB<TB<PB<.....
	
	1byte = 8bit
	1KB = 	1024byte
	1MB = 1024KB
	1GB = 1024MB
	1TB = 1024GB
	1PB = 1024TB
	....
	（3）数据类型的大小
	char                 //1byte
	short                //2byte
	int                  //4byte
	long                 //4byte
	long long            //8byte
	float                //4byte
	double               //8byte     
	（4）字符类型
	%d-打印整型
	%c-打印字符
	%s-打印字符串
	%f-打印浮点数字-小数（默认保留6位小数；%.2f保留两位）
	%lf-打印双精度浮点数
	%p-以地址的形式打印
	%x-打印16进制的数字
	%o-... 

	C语言中常量是不变的值，变量是可变的值
	创建变量的使用：
	
	int age = 10;
	char ch = 'w';
	float weight = 45.5f;
	 其中，age，ch，weight为变量。

int num = 100;              //全局变量
int main()
{
	int a = 10;             //局部变量
	return 0;
}

	C语言中的常量分为字面常量，const修饰的常变量，#define 定义的标识符常量，枚举常量。
	（1）字面常量：100，'w'，3.14等。
	（2）const修饰的常变量：const常属性，const修饰的常变量不可以被修改，如：
		int main()
		{
			const int num = 10;        //num不可被修改
			printf("num=%d", num);
			return 0;
		}
	（3）#define 定义的标识符常量，如：
		#define MAX 10                    //MAX是常量
		int main()
		{
			int arr[MAX] = { 0 };
			printf("%d\n", MAX);
			return 0;
		}
	（4）枚举常量（可以一一列举出来） ---枚举关键字-enum
		enum Sex
		{
			MALE,
			FEMALE,         //枚举常量
			SECRET
		};
		int main()
		{
			printf("%d\n", MALE); //0
			printf("%d\n", FEMALE); //1
			printf("%d\n", SECRET); //2
			return 0;
		}

	字符串-双引号""引起的
	单个字符-单引号''引起的
	字符串的结束标志是 '\0'，不算字符串内容（即计算字符串长度时不算进去），如：
	int main()
	{
		char arr1[] = "abc";            //"abc"---'a','b','c',0          
		char arr2[] = { 'a','b','c','\0'};
		printf("%s\n", arr1);
		printf("%s\n", arr2);

		printf("%d\n", strlen(arr1));   //strlen- 计算字符串长度，计算'\0'出现前的字符个数
		printf("%d\n", strlen(arr2));
		return 0;
	}

		常见转义字符：
		\n	    换行符
		\t	    水平制表符（tab）
		\b		退格符
		\r		回车
		\\      表反斜杠，防止它被解释为一个转义序列符      eg：打印abc\nd，printf("abc\\nd");
		\ddd	ddd表示1-3个八进制的数字（0~7）	                  eg：\32 表示32这个八进制的数字表示的十进制对应的ASCII码值的符号
		\xdd	dd表示2个十六进制的数字

	vs中快速注释按键：Ctrl+K+C
	vs中取消注释案件：Ctrl+K+U

	初识函数---一个相加函数

	int Add(int x,int y)            //x和y是形式参数；int是函数的返回类型；{}内是函数的函数体
	{
		int z = 0;
		z = x + y;
		return z;
	}
	int main()
	{
		int num1 = 10;
		int num2 = 20;
		int a = 100;
		int b = 200;
		int sum = 0;
		sum = Add(num1, num2);
		printf("sum=%d\n", sum);
		sum = Add(a, b);
		printf("sum=%d\n", sum);
		return 0;
	}

	数组：一组相同类型的集合

	char ch[10]；
	int arr[10];

	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	char arr1[] = {'b','i','t'};
	char arr2[] = "bit";

	数组的下标是从0开始的，即数组的第一个元素下标是0。如：
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	arr[5]是arr数组以5为下标的元素，即为6。

	int main()
	{
		int arr[10] = {1,2,3,4,5,6,7,8,9,10};
		int i = 0;
		while (i < 10)
		{
			printf("%d ", arr[i]);
			i++;
		}
		return 0;
	}

	+  加法
	-  减法
	*  乘法  
	/（取商）--- 除法操作符的两端如果都是整数，执行的是整数除法；只要有一个操作数是浮点型，执行的就是浮点型除法  
	%（取余）--- 只能作用于整数

	 <<(左移)2进制---左移1位相当于*2
	 >>(右移)2进制---右移1位相当于/2

	 & 按位与
	 | 按位或
	 ^ 按位异或(对应二进制位相同则为0，相异则为1)

	=   +=   -=   *=   /=   &=   ^=    |=   >>=   <<=

	!           逻辑反操作
	-           负值
	+           正值
	&           取地址
	sizeof      操作数的类型长度（以字节为单位）
	~           对一个数的二进制按位取反
	--          前置、后置--
	++          前置、后置++
	*           间接访问操作符(解引用操作符)
	(类型)       强制类型转换

	>
	>=
	<
	<=
	!=   用于测试“不相等”
	==   用于测试“相等”

	&&     逻辑与 （并，同时为真才是真）
	||     逻辑或 （其中一个真就真）

	exp1 ? exp2 : exp3
	exp1如果为真，执行exp2，否则执行exp3.
	
	eg：
	int main()
	{
		int a = 10;
		int b = 20;
		int max = 0;
		max = (a > b ? a : b);
		printf("max=%d\n",max);
		return 0;
	}

	从左往右依次执行，整个表达式的结果是最后一个表达式的结果。

	auto  break   case  char  const   continue  default  do   double else  enum   
	extern float  for   goto  if   int   long  register    return   short  signed
	sizeof   static struct  switch  typedef union  unsigned   void  volatile  while

	typedef可以把类型重命名，如：
	
	int main()
	{
		typedef unsigned int u_int;
		unsigned int a = 10;
		u_int b = 20;
		printf("%d\n", a);
		printf("%d\n", b);
		return 0;
	}

	在C语言中：
	static是用来修饰变量和函数的.
	
	1. 修饰局部变量-称为静态局部变量---使局部变量出了作用域不会销毁，使局部变量的生命周期变长
	如：
	void test()
	{
		static int a = 1;      //如果不加static，每次调用test()时a都会被销毁，重新赋值，加了static会储存a的值
		a++;
		printf("a = %d\n", a);

	}
	int main()
	{
		int i = 0;
		while(i<5)
		{
			test();
			i++;
		}
		return 0;
	}
	2. 修饰全局变量-称为静态全局变量---使静态的全局变量只能在自己所在的源文件内部使用，出了源文件就没法使用了
	3. 修饰函数-称为静态函数---改变了函数的链接属性（让函数只能在自己所在的源文件内部使用）

	//define定义标识符常量
	#define MAX 1000
	
	//define定义宏
	#define ADD(x, y) ((x)+(y))
	int main()
	{
	    int sum = ADD(2, 3);
	   printf("sum = %d\n", sum);

	   sum = 10*ADD(2, 3);
	   printf("sum = %d\n", sum);

	 return 0;
	}

	内存划分为很多个内存单元，一个内存单元的大小是一个字节，一个内存单元给一个地址。

	int main()
	{
		int a = 10;
		int* p = &a;
		//int* 是指针的类型（若是字符就是char*）
		*p = 20;
		//*---解引用操作符，此步操作是改变存放在指针变量p里面的值；*p就是通过p的地址找到p的值
		printf("%d\n", a);
		printf("%p\n", &a); //&a可换成p
		//打印指针用%p
		printf("%d\n", sizeof(p));
		return 0;
	}

	指针变量的大小取决于地址的大小
	32位平台下地址是32个bit位（即4个字节）
	64位平台下地址是64个bit位（即8个字节）

	typedef struct Stu            //把struct Stu重新起名字为Stu，在；前起新的名字
	{
		char name[20];
		short age;
		char tele[12];
		char sex[5];
	}Stu;                          //Stu：类型

	int main()
	{
		Stu s1 = { "张三",30,"15236985412","男" };            //初始化变量，结构体初识化要用{} 
		Stu s2 = { "李四",20,"15421410451","男" };
		printf("%s %d ", s1.name, s1.age);                   //结构体变量.成员

		printf("\n");

		Stu* ps = &s1;
		printf("%s %d ", ps->name, ps->age);                //结构体指针->成员
		return 0;
	}