C语言核心知识点总结

一、数据类型

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

double d = 3.14;
printf("%lf\n", d);

unsigned char i ;//0~255
char i//-128~0~127

1.为什么出现这么多类型？

printf("%d\n",sizeof(char));	//1
printf("%d\n",sizeof(short));	//2
printf("%d\n",sizeof(int));		//4
printf("%d\n",sizeof(long));	//4/8
printf("%d\n",sizeof(long long));//8
printf("%d\n",sizeof(float));	//4
printf("%d\n",sizeof(double));	//8

注：同一类型的有符号数和无符号数所占字节数相同

short int age = 20;  //2^16=65535

即，为了更加丰富的表达生活中的各种值

数据的存放方式

常量与变量

1.作用域

当局部变量和全局变量相同时，局部变量优先。

//取地址符号&
scanf("%d%d",&num1,&num2);
//避免编译器提示语法不安全
#define _CRT_SECURE_NO_WARNINGS 1

声明extren外部符号的

extern int g_val;
printf("g_val = %d\n", g_val);

2.变量的生命周期

• 局部变量的生命周期：进入作用域生命周期开始，出作用域生命周期结束。
• 全局变量的生命周期：整个程序的生命周期

3.常量

• 字面常量
• const修饰的常变量
• #define定义的标识符常量
• 枚举常量

const int num = 4;
num = 8 //不能进行更改

int  n = 10;
int arr[n] = {0};//应该放入常量表达式

enum Sex
{
	MALE,
	FEMALE,
	SECRET
};
int main()
{
	printf("%d\n",MALE);	//0
	printf("%d\n",FEMALE);	//1
	printf("%d\n",SECRET);	//2
	enum Sex sex = MALE;
	sex = FEMALE;	//可更改
	FEMALE = 6;		//不能更改
}

数组 字符串

int main()
{
	char arr1[] = "abc";
	//'a','b','c','\0'
	//'\0'：字符串的结束标志 
	char arr2[] = {'a','b','c'};
	char arr3[] = {'a','b','c','\0'};
	printf("%s\n",arr1); //abc
	printf("%s\n",arr2); //abc烫烫烫bc
	printf("%s\n",arr3); //abc
	printf("%d\n",strlen(arr1));//3
	printf("%d\n",strlen(arr2));//随机值
	
	printf("%d\n",strlen("c:\test\32\test.c"));//13
	//32是两个8进制数字，转化为10进制后ASCII码值所对应的字符
	char arr4[5] = {'a',98};
	printf("%d\n",sizeof(arr4));//2,所占字节大小
	printf("%d\n",sizeof(arr1));//4
}

1.二维数组

int arr[][4] = {{1,2,3,4},{5,6,7,8}};
//列下标不能省略

参数是数组的形式

参数是指针的形式

*((*p+i)+j) =  (*(p+i)[ j ])

指针

存放内存单元的地址，内存单元以字节为单位
*–>解引用操作符
指针大小在32位平台是4个字节

double d = 3.14;
double* pd = &d;
//sizeof(pd) = sizeof(double*)

指针类型决定了指针解引用操作的时候，能够访问空间的大小
int *p;//能够访问4个字节
char *p;//能够访问1个字节
指针类型决定了指针的步长
int *p; //p+1->4
cahr *p; //p+1->1
double *p; //p+1->8

1.指针数组

2.数组指针

3.总结

指针进阶

1.函数指针

2.函数指针的数组

可代替switch语句

3.指向函数指针数组的指针

排序函数

字符串函数

关键字（static define）

static修饰局部变量：使得局部变量的生命周期变长
static修饰全局变量：使得全局变量的作用域变窄，另一函数进行extern声明时发生错误
static修饰函数：改变了函数的链接属性，使得外部链接属性转化为内部链接属性

宏定义

#define MAX(X,Y) (X>Y?X:Y)
int main()
{
	max = MAX(a,b);//max = (a>b?a,b)
}

结构体

//结构体变量.成员
//结构体指针->成员
struct Book
{
	char name[20];
};
int main()
{
	struct Book b1 = {"CCC"};
	struct Book* pb = &b1;
	printf("%s\n",b1.name);
	printf("%s\n",(*pb).name);
	printf("%s\n",pb->name);
//更改成员数据
	b1.name = "uuuu"//err
	strcpy(b1.name,"uuuu");//string.h
}

循环

	int i = 1;
	while(i<10)
	{
		if(i == 5)
			continue;
		printf("%d",i);
		i++;
	}
	//陷入死循环，当i=5时，跳到while，然后到continue，还会回到while

	//ctrl+z 可结束
	while(ch = getchar()! = EOF)
	{
		putchar(ch);
	}
	char password[20] = {0};
	scanf("%s",password);
	ret = getchar();
	//当输入完后，按下回车键，‘\n’就会被ret接收
	while(ch=getchar()!='\n')
	{
		;
	}
	//将缓冲区读取完

for语句的循环控制变量：
1.不可在for循环体内修改循环变量，防止for循环失去控制
2.建议for语句的循环控制变量的取值采用“前闭后开区间”的写法

	int i=0,k=0;
	for(i=0,k=0;k=0;i++)
		k++;
	//不进入循环，k=0为假

#include
Sleep(1000);
#include
system("cls");//清空屏幕
//时间戳
srand((unsigned int) time()); 
ret = rand()

函数

1.函数的调用

形参实例化之后其实相当于实参的一份临时拷贝。

而传址调用可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量

printf函数返回的是字符的个数

2.递归

1.存在限制条件，当满足这个限制条件的时候，递归便不再继续

//计算字符串长度
//char arr[] = "bit";
//int len = my_strlen(arr);
int my_strlen(char *str)
{
	if(*str!='\0')
		return 1+my_strlen(str+1);
	else
		return 0;
}

3.数组作为函数参数

//arr是数组，对数组arr进行传参，实际上传递过去的是数组arr的首元素的地址 &arr[0]
buble_sort(arr,sr);

4.指针作为参数

操作符

1.算术操作符

除了%操作符之外，其他的几个操作符可以作用于整数和浮点数。

2.移位操作符

1.算术右移：右边丢弃，左边补原符号位
2.逻辑右移：左边补零

3.逻辑操作符

^异或运算，相同为0，不同为1
！逻辑反操作
EOF：文件结束标志

取反

	int a = 0；//4个字节，32bit位
	int b = ~a;//b是有符号数的整形
	//存储的是补码，打印出的是原码，b=-1
	

动态内存

#include 
#include 
#include 
int main()
{
	//像内存申请10个整形的空间
	int* p = (int *)malloc(10*sizeof(int));
	if(p==NULL)
	{
		//打印错误原因的一个方式
		printf("%s",strerror(errno));
	}
	free(p)
	p=NULL;
	return 0;
}

柔性数组

文件操作