****************************************************************************************************************************************************************************************************************
操作符解释：
1，算术操作符：
‘+’、‘-’、‘*’、‘/’、‘%’
%取模操作符只能用于整数，
/除法操作符，两个操作数均是整数时为整数除法，有一个是浮点数则执行浮点数除法。
如：int a = 6/5;//->a==1
double b = 6/5;//->b==1.000000
double c = 6.0/5//->c==1.200000，即实际运算与定义的储存类型无关
2,移位操作符
左移‘<<’、右移‘>>’
左移操作符：
如： int a=2;
int b = a << 1;//a向左移动一位，结果存入变量b中，结果b为4
正整数2在内存中存放的补码为： 00000000000000000000000000000010
向左移动一位，左边的首位0去掉，右边的缺一位补0：00000000000000000000000000000100 ->4(十进制)
右移操作符：
右移时分为算数右移和逻辑右移。
算数右移：右边丢弃，左边补符号位。
逻辑右移：右边丢弃，左边补0。
如：int a = -10;
int b = a >> 1;//a向右移动一位，结果存入变量b中
正整数10在内存中的补码为11111111111111111111111111110110//若为负数则原码与补码不同。
算术右移： 11111111111111111111111111111011 ->-5
逻辑右移： 01111111111111111111111111111011 ->2,147,483,643
对移位操作符移动负数位，这时C语言未定义的，不要使用。
3，位操作符
按位与‘&’、按位或‘|’、按位异或‘^’
位解释为二进制的一位。
&按位与，全为1时结果才为1，其他情况结果均为0
如：int a = 3;// 00000000000000000000000000000011
int b = 5;// 00000000000000000000000000000101
int c = a & b;// 00000000000000000000000000000001->1(十进制)
eg：找出一个整数的二进制的1的个数。
#include <stdio.h>
int main(){
int a=1;
int cnt=0;
for(int i=0; i<31; i++){
if((a&1) == 1){//整数的二进制数的1的个数
cnt++;
}
a=a >> 1;
}
printf("%d\n",cnt);
return 0;
}
|按位或，全为0时结果才为0，其他情况结果均为1
如：int a = 3;// 00000000000000000000000000000011
int b = 5;// 00000000000000000000000000000101
int c = a | b;// 00000000000000000000000000000111->7(十进制)
^按位异或，不同为1，相同为0。一个数a与另一个数b异或两次结果仍是a本身，数a与0异或结果仍为数a。
如：int a = 3;// 00000000000000000000000000000011
int b = 5;// 00000000000000000000000000000101
int c = a ^ b// 00000000000000000000000000000110->6(十进制)
eg：交换两个数a=3，b=5，要求不使用第三个变量。
#include <stdio.h>//此法适用于a，b相加的结果不超过类型范围的情况，有缺点
int main(){
int a=3;
int b=5;
a = a + b;//变量a储存a与b的和
b = a -b;//变量b储存原来a的值
a = a - b;//变量a储存原来b的值
return 0;
}
#include <stdio.h>//此法适用于a，b相加的结果不超过类型范围的情况，有缺点
int main(){
int a=3;
int b=5;
a = a ^ b;
b = a ^ b;//3 ^ 5 ^ 5的结果3存入到b中
a = a ^ b;//3 ^ 5 ^ 3的结果5存入到a中
return 0;
};
4，赋值操作符
= += -= *= /= %= <<= >>=
‘=’是赋值，‘==’是等号。
int a = a + 4;//等价于a+=4;
连续赋值：
如：int b = a = a+1；//等价于a = a + 1; b = a;
连续赋值不好进行调试，阅读不便。
5，单目操作符
!(逻辑反) -(负值) +(正值) ~(按位取反) sizeof(操作数的类型长度，按字节计算) -- ++ &(取地址) *(间接访问操作符或解引用操作符) （类型名）强制类型转化
‘i’一般用于条件判断，0的反是1，非0的反是0；
如：
#include <stdio.h>
int main(){
int flag =0;
if(flag){
printf("Yes\n");//条件为假，语句不执行
}
if(!flag){
printf("YesYes\n");//条件为真，语句执行
}
return 0;
};
‘~’对二进制位的操作，类比按位与、按位或、按位异或。最高位也参与取反。
如：int a = 13；//00000000000000000000000000001101
int b = ~a; //11111111111111111111111111110010 -> b==-14;
‘sizeof’是单目操作符，可求内存大小。
如： int a =13；
int b = sizeof(a);//结果为4，是一个int类型变量所占字节个数，也可写为int b = sizeof a; 不需要加括号
int arr[10]={0};
int c = sizeof(arr);//结果为40，是十个int类型变量所占字节个数
int g = sizeof(int [10]);//结果为40，数组的类型实际上是去掉数组名（arr）之后留下的（int [10]）。
如：
#include <stdio.h>
int main(){
short s = 5;
int a = 10;
printf("%d\n",sizeof(s = a + 2));//输出为2，short占2字节，等价于printf("%d\n", sizeof(s));。
printf("%d\n",s);//输出为5，上面表达式没有计算
return 0;
};
‘++’
int a = 13;
++a;//前置++,先++在使用
a++;//后置++，先使用，在++
‘&’取地址操作符，单目操作符，与按位与操作符区分
‘*’解引用操作符或间接引用操作符
如：#include <stdio.h>
int main(){
int a =13;
int *p = NULL;//定义int类型的指针变量，此时 * 是定义
p = &a;//整型指针变量p中存放整型变量a的地址
printf("%d\n",*p);//此句输出为13，*p与a等价。此时 * 是解引用
int a =1;
char b=1;
double c=1;
float d=1;
int *pa =&a;
char *pb =&b;
double *pc=&c;
float *pd=&d;
printf("%d\n",sizeof(pa));
printf("%d\n",sizeof(pb));
printf("%d\n",sizeof(pc));
printf("%d\n",sizeof(pd));//输出相同，为4或8（与具体系统有关），求的是指针变量的大小，不论是那种类型的指针变量，储存的地址形式都相同，内存的地址（指针常量）形式是确定的
}
‘（类型名）’，
如：#include <stdio.h>
int main(){
int a = 3.14;//浮点型转换为int型会损失精度，产生警告。
int b =(int)3.14;//强制类型转换，没有警告。
return 0;
}
6，关系操作符
=(赋值) ==(相等) <、>、<=、>=、!=(不等于)
字符串比较不能用==，要用字符串函数
7，逻辑操作符
&&(逻辑与) ||(逻辑或)
首先和按位与（&）、按位或（|）区分开。
逻辑与：全真为1，其它为0。
逻辑或：全0为0，其它为1。
短路现象：对于逻辑与：
如： #include <stdio.h>
int main(){
int a=0,b=3,c=2,d=4;
if(a && b && c && d)//先看a && b，a==0，则最终表达式结果一定为0，后面表达式不再计算
printf("111\n");
else{
printf("000\n");//最后输出为000
}
}
对于逻辑或：
如： #include <stdio.h>
int main(){
int a=5,b=3,c=2,d=4;
if(a || b || c || d)//先看a || b，a == 5，则最终表达式结果一定为1，即为真，后面表达式不再计算，输出为111。
printf("111\n");
else{
printf("000\n");
}
}
8，条件操作符
? : (三目操作符)
如：#include <stdio.h>
int main(){
int a =2;
int b = 4;
printf("%d\n", a>b?a:b);//如果a>b表达式成立，则表达式结果为a，否则为b，输出为4。
return 0;
}
9，逗号表达式
逗号表达式，从左向右依次计算，整个表达式的值是最后一个子表达式的值。
#include <stdio.h>
int main(){
int a =2;
int b = 4;
printf("%d\n", (a=a+3,b=b-2));//表达式a = a + 3计算，但整个表达式(a=a+3,b=b-2)的值是表达式（b=b-2）的值，结果为2
b = 4;
printf("%d\n", b=b-2);//结果为2
}
10，下标引用、函数调用和结构成员访问
[ ]下标引用操作符（运算符）
操作数：一个数组名+索引值，类比二元操作符，1 + 2。
如： #include <stdio.h>
int main(){
int a[10];//创建数组
a[0] = 10;//使用下标引用操作符为数组第一个单元赋值
}
( )函数调用操作符，接受一个或多个操作数，第一个操作数是函数名，剩余的操作数是函数的参数。
如： #include <stdio.h>
int max(int a, int b){//函数定义
return a > b ? a : b;
}
int main(){
int a = 3;
int b = 4;
max(a, b);//函数调用，输出二者中较大的那个数。
printf("%d\n",t);
return 0;
}
结构成员访问操作符：对于非指针变量使用圆点操作符，指针变量还可以使用箭头操作符
如：
#include <stdio.h>
struct student{
char name[20];
int age;
double mathscore;
};
int main(){
struct student a = { "weihe", 20, 90};
printf("%s\n",a.name);//使用圆点操作符访问结构体成员name数组
struct student *p = NULL;
p = &a;
printf("%d\n", (*p).age);//使用指针解引用访问结构体成员age
printf("%d\n", p->age);//使用箭头操作符访问结构体成员age
return 0;
}
11，表达式求值
求值顺序由操作符的优先级和结合性决定。有些表达式的操作数再求值的时候可能要转换为其他类型。
12，隐式类型转换
C的整型算术运算是以缺省（sheng）整形类型的精度来进行的。
为了达到这个缺省（sheng）整形类型的精度，表达式中的字符和短整型操作数（2字节）在使用之前被转换为普通整型（int或unsigned int），这种转换称为整形提升。
整形提升的意义：
表达式的整型运算在CPU相应的运算器件内执行，CPU内整型运算器的操作数的字节长度一般是int的字节长度，同时也是CPU的通用寄存器的长度。
即使是两个字符型变量相加，CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
通用CPU难以直接实现两个8bit字节的直接相加运算（虽然机器指令中可能有这种字节相加指令）。
整形提升过程：
按照变量数据类型的符号位提升。
正数： char a = 1;//00000001（补码） ->（整形提升） 00000000000000000000000000000001
负数： char b = -1//11111111 （补码）-> （整形提升）11111111111111111111111111111111
如： #include <stdio.h>
int main(){
char a = 3;
char b = 127;
char c = a + b;// a: 00000011 -> 00000000000000000000000000000011
// b: 01111111 -> 00000000000000000000000001111111
c: 00000000000000000000000010000010 ->（截断） 10000010
printf("%d\n", c);/ c: 10000010 -> 11111111111111111111111110000010（反码）->（求原码）10000000000000000000000001111110 即为-126
return 0;//以int型输出是也会发生整型提升，对于unsigned char，整型提升时高位均补0
}
#include <stdio.h>
int main(){
char c =0；//sizeof返回类型为size _t,是unsigned int，打印时要用格式符%u
printf("%u\n",sizeof(c));结果为1
printf("%u\n",sizeof(-c));结果为4，sizeof运算符括号里的表达式（-c）虽然不参与运算，但有类型属性，为整形提升后的int
printf("%u\n",sizeof(+c));结果为4
printf("%u\n",sizeof(!c));结果为4
return 0;
}
****************************************************************************************************************************************************************************************************************
字符串
相关函数
头文件#include <string.h>
求长度
char s[10] = "hello world";
strlen(s),返回字符的个数
sizeof(s),返回字符串大小，包括'\0'
复制函数
char s1[10];//字符数组
char s2[10] = "hello";
strcpy(s1,s2),把字符串s2整体复制到s1中，但s1中要有足够的内存
strncpy(s1,s2,n),对s2最多n个字符成立
比较函数
strcmp(s1,s2),相等返回0，s1>s2返回正整数，s1<s2返回负整数
strncmp(s1,s2,n),字符串s1中最多n个字符与字符串s2比较，同上
连接函数
char s1[10];//字符数组
char s2[10] = "hello";
strcat(s1,s2),把s2中字符添加到s1中有效字符之后，s1要有足够的内存
strncat(s1,s2,n),对s2最多n个字符成立
逆置函数(倒序)
char s[10] = "hello";
strrev(s),
输出函数
sprintf(s,格式字符串,输出项列表),输出到字符串s中，不在屏幕上显示
输入函数
sscanf(s,格式字符串,输出项列表),从字符数组s中读取，而不是从键盘读取，
字符串数组与函数
****************************************************************************************************************************************************************************************************************
数组
&arr//指数组的地址，(&arr+1)加了整个数组的长度
arr//指数组首元素的地址，(arr+1)加了一个数组元素的长度
arr[0]//指数组首元素的地址
二维数组的函数调用
void pow(int a[][10])//一个调用二维数组的函数
int arr[10][10];
pow(arr);//只写数组名
****************************************************************************************************************************************************************************************************************
刷新函数
memset（数组名，0，sieof(数组名)）；
****************************************************************************************************************************************************************************************************************
指针(间接引用)(地址)
指针常量：计算机内存中的事先实现好的编号即地址，不可改变。
指针变量：指针类型，储存地址的变量，可以改变，指针变量自身也占有一定内存。不与指针常量混淆时简称为指针。
指针的大小：
指针在32位系统中占4字节，在64位系统中占8字节，与地址占内存的大小有关。
而在同一系统中地址由多个相同的bit构成
变量(int,float,double,char等)占用内存中的字节，首个字节的地址是该变量的地址
初始化
声明指针时必须对其进行初始化(为0，NULL，已定义变量地址)。
如：
void *p = NULL;//可以指向任何类型的指针，未知指向变量的数据类型，不能进行间接寻址运算
int *p = NULL;//不指向任何对象
int *p = 0;
int a = 1;
char *p = &a;//指向变量a的地址
间接寻址运算(运算符*，&)
*：解引用操作符，访问指针p所指的变量a。
&：取(返回)变量a的地址。
int a = 1;
int *p = &a;//此时*为指针声明符
有*p与a等价，p与&a等价
指针的算术运算
加法运算：(得到另一个地址)
int a[4]={4,5,3,1};
int *p = a;//或p = &a[0];
有(p + 1) == &a[1];.......(p + i) == &a[i];
减法运算: (得到地址之间的距离，用元素的个数表示)
int a[4]={4,5,3,1};
int *p = &a[0];
int *q = &a[3];
则p - q == 3.//结果可以为负整数，即地址相减后除以类型所占的字节
地址之间的距离==sizeof(int)*3.
指针比较：(指向相同数组时才有意义)
int a[4] = {5, 4, 3, 2, 1};
int *p = &a[0];
int *q = &a[4];
for(; p<=q; p++){
printf("%d\n", *p);//循环输出数组各元素
}
指针与数组：
int a[4];
由数组名a可知数组a的内存大小并得到数组a的首元素的第一个字节的地址(即数组名a是指向a[0]的一个指针常量,，指针常量，不可更改)。
int *p = a;
int i;
一个指针p与数组a关联之后数组a中的元素表示方法可以为：(以指针p指向数组首元素为例)
数组下标表示: a[i];
数组偏移量表示: *(a + i);//偏移量，即i
指针下标表示: p[i];
指针偏移量表示: *(p+i);
数组作为函数的参数:
形参数组(定义的函数中，非main函数)本质上是一个相应类型的指针变量，不是指针常量.
例如
int a[4];//实参
函数头void sum(int a[], int n)//形参a[]获得了数组的首元素的指针(地址)，可以访问和修改数组a[4]中的所有元素
与void sum(int *a, int n)等价
指针与const限定符: (减小函数的在主函数的权限等)
const修饰后，为常量，不可修改。
定义函数时
声明为从const的指针要在声明时就初始化，若为定义的函数参数则由相应主函数的实参初始化。
可变指针指向可变(可修改的)数据：
void sum(char *p,int n)//权限最大，无const约束指针或类型数据(char).
可变指针指向常量(不可修改的)数据:
void sum(const char * p, int n)//应从右往左理解const char * p，p是一个指针，指向字符常量，可进行指针运算。
常量指针指向可变数据:
void sum (char const * p, int n)//从右往左char const * p，p是一个指针常量，指向字符型数据，可改变指针指向数据的值。
常量指针指向常量数据:
void sum(const char const * p,int n)//权限最小，指针(地址)的值不能改变，其指向的数据也不能改变
指针数组：是一个数组，数组元素时一个个指针变量
char* arr[4];//一级字符指针数组
char** arr[4];//二级字符指针数组
如： #include <stdio.h>
int main() {
int a = 10;
int b = 20;
int c = 30;
int *arr[3] = { &a,&b,&c };//注意[ ]优先级比*高
int i = 0;
for(i=0; i<3; i++){
printf("%d\n", *arr[i]);
}
return 0;
}
#include <stdio.h>
int main() {
int a[5] = { 1,2,3,4,5 };
int b[] = { 1,3,5,7,89 };
int c[] = { 2,3,4,5,6 };
int* arr[3] = { a,b,c };//先是一个数组，数组中的元素为int*，即整型指针。
int i = 0;
for (i = 0; i < 3; i++) {
int j = 0;
for (j = 0; j < 5; j++) {
//printf("%d ", *(arr[i] + j));//arr[i]是指针数组第一个元素储存的地址即a数组首元素的地址，(arr[i]+j)是a数组中第j个元素的地址
printf("%d ", arr[i][j]);//等价于二维数组
}
printf("\n");
}
return 0;
}
数组指针：
如： #include <stdio.h>
int main() {
int a = 10;
int* pa = &a;//整型指针
char ch = 'w';
char* pch = &ch;//字符指针
int arr[10] = { 0 };
int (*parr)[10] = &arr;//取出的是数组arr的地址，不是数组首元素的地址。先是是一个指针，再指向具有10个元素的数组，数组中的元素为int。
double* b[5];//指针数组
double* (*p)[5] = &b;//数组指针，即指向指针数组的指针。先是一个指针，再指向具有5个元素的数组，数组中的元素为double*。
return 0;
}
（&数组名）与数组名（首元素的地址）区别：
#include <stdio.h>
int main() {
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);//输出arr与&arr地址的值相同，意义不同（类型不同）。
//
int* pa = arr;//类型为int
int(*pb)[10] = &arr;//类型为int [10]或int []。
printf("%p\n", pa);//指针加一跳过指向对象的大小。
printf("%p\n", pa+1);//指针加一跳过一个int大小，为4字节。
printf("%p\n", pb);
printf("%p\n", pb+1);//指针加一跳过一个int [10]大小，为40字节。
return 0;
}
数组名是首元素的地址，但有两个例外：
1：sizeof(数组名) - 数组名表示整个数组，计算的是整个数组大小，单位是字节。
2：&数组名 - 数组名表示整个数组，取出的是整个数组的地址。
数组指针的使用：数组指针中存放数组的地址
如：用于一维数组，一般不使用数组指针，使用一级指针就可以了，使用数组指针反而麻烦。
#include <stdio.h>
int main() {
int arr[5] = { 1,2,3,4,5 };
int(*pa)[5] = &arr;//指向含有五个整型元素数组的指针，储存的是整个数组的地址
for (int i = 0; i < 5; i++) {
printf("%d " ,*((*pa) + i));
//首先*pa是数组arr，而数组arr是数组首元素的地址，故*pa是数组首元素的地址
//接着*pa+j是数组中下标为j的元素的地址，*((*pa)+j)是下标为j的元素
}
return 0;
}
用于二维数组
#include <stdio.h>
//void print(int arr[3][4], int m, int n) {//常规写法
// for (int i = 0; i < m; i++) {
// for (int j = 0; j < n; j++) {
// printf("%d ", arr[i][j]);
// }
// printf("\n");
// }
void print2(int(*pa)[4],int m, int n) {//定义了指向一维数组的指针，
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", *(*(pa + i) + j));
//*(pa+i)首先是二维数组第i-1行的地址，*(pa+i)+j是第i-1行的第j-1个元素的地址
//*(*(pa+i)+j)是第i-1行的第j-1个元素
}
printf("\n");
}
}
int main() {
int arr[3][4] = { {1,2,3,0},{4,5,6,0},{7,8,9,0} };
//print1(arr, 3, 4);
print2(arr, 3, 4);
return 0;
}
int arr[5];//一维整型数组
int a[3][4];//二维整型数组
int* parr1[10];//指针数组，该指针指向存放10个整型指针的数组
int(*parr2)[10];//数组指针，指向存放10个整型元素的数组
int(*parr3[10])[5];//存放10个数组指针的数组，每个数组指针指向存放5个整型变量的数组
函数参数传递方式：按值传递和按引用传递
C中均为按值传递：被调函数的形参为主调函数的副本(拷贝)，一般不影响主调函数变量的值。当传入指针时(类似按引用传递)，主调函数
向被调函数传入了地址，可以改变主调函数中的相应变量的值。
如：void swap(int *p, int *q)//函数定义
int a=5, b=6;
swap(&a, &b);//函数调用
数组参数与指针参数
一维数组传参：
#include <stdio.h>
void test1(int arr[10]) {//1一维数组接收，可以
}
void test1(int arr[]) {//1一维数组接收，可以
}
void test1(int* arr) {//1一级指针接收可以
}
void test2(int* pa[10]) {//2一维指针数组接收，可以
}
void test2(int* pa[]) {//2一维指针数组接收，可以
}
void test2(int** pa) {//2可以
}
int main() {
int arr1[10] = {0};
int* arr2[20] = {0};
test1(arr1);//传的是首元素的地址，此指第一个元素int的地址
test2(arr2);//此指第一个元素int*的地址，即是二级指针
return 0;
}
二维数组传参：
#include <stdio.h>
void test3(int arr[3][4]) {//3二维数组接收，可以
}
void test3(int arr[][4]) {//3二维数组接收，可以
}
void test3(int arr[][]) {//3二维数组接收，列元素必须写，不可以
}
void test3(int* arr) {//一级指针接收，类型不匹配，不可以
}
void test3(int* arr[4]) {//一维指针数组接收，类型不匹配，不可以
}
void test3(int(*pa)[4]) {//一个数组指针接收，可以
}
void test3(int** arr) {//二级指针接收，与一维数组的地址不匹配，不可以
}
int main() {
int arr[3][4] = { 0 };
test3(arr);//传的是二维数组的首元素的地址，此指第一个元素一维数组的地址
return 0;
}
函数指针
指针函数
****************************************************************************************************************************************************************************************************************
结构体（构造类型）
struct关键字用于结构体定义。
结构是同一名字下的一组相关变量的集合。可以包含不同的数据类型。（当然包括结构类型）
结构体定义（声明）形式：
struct 结构标识符{ 如：struct student{
数据类型 成员1; char name[20];
数据类型 成员2; int age;
...... double mathscore;
};
};
定义之后，struct student便成为了自己定义的新的一种数据类型，与char、int、float、double使用基本相同。编译器不对数据类型分配内存，
当定义了相应类型的变量时编译器会为该类型的变量分配内存。自定义结构类型也是这样。
typedef关键字：为任意数据类型起一个别名，便于使用和理解。
关于结构体使用：
如：typedef struct student STU，即STU成为struct student 数据类型的另一个名字。
或如：typedef struct student{
char name[20];
int age;
double mathscore;
}STU;此STU不是struct student类型的结构变量，而是struct student 数据类型的另一个名字。
结构变量的声明（定义）：
a.先声明结构类型，在定义结构变量。
如：struct student a;
b.定义结构类型的同时，定义结构变量。（此时结构标识符可以省略，且只能在此处定义结构变量，少使用）
如：struct student{
char name[20];
int age;
double mathscore;
}a;
结构变量的内存用sizeof运算符计算出，一般大于结构成员所占字节的和。
结构类型可以作为另一个结构的成员：
struct date{
int year;
int month;
int day;
}
struct student{
char name[20];
int age;
double mathscore;
struct date born;
};
结构变量的初始化：
与普通变量一样，不同成员用逗号隔开，字符串用双引号，单个字符用单引号。
如：struct student a = { "weihe", 20, 90};
结构成员的访问方法：C规定结构变量不能整体进行输入输出比较等操作，只能对具体的成员进行输入输出比较等操作。
相同类型的结构变量可以直接进行赋值操作，等价于结构变量成员依次进行赋值操作。
使用成员选择运算符（圆点运算符）：
struct date{
int year;
int month;
int day;
}
struct student{
char name[20];
int age;
double mathscore;
struct date born;
};
struct student a = { "weihe", 20, 90, {2000,4,24}};
a.name == "weihe";//成员引用
a.age == 20;
a.date.year == 2000;//嵌套结构体的级联引用
结构数组：数组中元素均为结构类型。（定义和初始化）与普通数组相同。
结构指针：指向结构的指针。
成员访问运算符对于指针：圆点运算符和箭头运算符
如：struct student{
char name[20];
int age;
double mathscore;
};
struct student a[20]={ {"weihe",20,90},
{"齐天大圣",1000,95}};//初始化，未初始化的赋值为0。
struct student b；
a[4].age = 20;//对结构数组第5个元素中的一个变量赋值（引用）。
struct student *p = NULL;//定义结构指针。
p = &b;//得到结构类型b的地址用用取地址运算符。
p = a;//数组名就是数组的地址故不需要取地址运算符，等价于 p = &a[0];.
(*p).mathscore = 89;//同时使用解引用运算符与圆点运算符,等价于a[0].mathscore = 89;
*(p+1).mathscore = 79;//同时使用解引用运算符与圆点运算符，等价于a[1].mathscore = 79;，指针+1则跳过相应类型的一个元素，再此为一个结构元素。
p->mathscore = 99;//箭头运算符，等价于 a[0].mathscore = 99;
当p定义为指向结构类型的指针时就只能指向定义的类型了，不能指向结构类型中的成员，
但可以通过成员访问运算符（圆点或箭头）访问成员。对于结构指针有两种（圆点和箭头），对于结构名只有圆点运算符。
结构与函数：
struct student{
char name[20];
int age;
double mathscore;
};
void max(int n, struct student a);//结构作为函数的参数，是按值传递，在max函数新建一个结构体（形参），不影响main函数里传参的的结构体（实参）。不常用。
void max(int n,struct student *a);//结构指针作函数参数，传入的是main函数里实参（再此为结构体）的地址，影响实参数值。常用。
void max(int n, struct student a[]);//结构数组作函数参数，与结构指针作用相同，传入的是数组的首元素字节的首地址。
struct student max(int n);//结构作函数返回值，max函数最终返回一个结构（其中一般包含多个结构成员，可一次性返回），类似返回其他类型数据。
联合：C语言中多个不同变量共享同一内存区的功能。
关键字：union
定义：（类比结构）
union student {//该联合的三个成员共享一个声明联合的内存单元，须有，同一时间内有且只有一个成员有意义。不能为联合的所有成员都初始化，只能用相应类型的常量为第一个成员初始化。
int n;//4字节
double a;//8字节
char ch;//1字节
}u;//定义的同时可以声明一个联合u。
union student u1；//也可在定义之后再声明一个联合u1。
在为声明的一个联合u分配内存大小时，编译器按成员中最长的类型double分配储存单元。
联合指针：
union student {
int n;//4字节
double a;//8字节
char ch;//1字节
}u,u1;
union student *p = NULL；
p = &u;
u1.n = p->n;//p->n等价于*p.n。 类比结构。圆点运算符与箭头运算符。
联合与结构：结构可以是联合的成员，联合也可以是结构的成员，能互相嵌套。
如： struct yes{//有对象问名字与年龄
name[20];
int age;
};
struct no {//无对象问希望什么时候找与喜欢类型
int hopeseektime;
char liketype[50];
};
union otherhalf{定义一个联合是否有对象，成员为两个结构分别表示有或没有
struct yes a;
struct no b;
};
struct student {//定义学生的结构，包括姓名、年龄与有无对象。
char name[20];
int age;
union otherhalf;
};
枚举：一种值由程序员列出的类型，而且程序员必须为每个值命名（枚举常量）。
关键字：enum（类比结构）
在枚举类型声明语句中，花括号内的标识符都是整型常量，称为枚举常量。一般第一个枚举常量是0，依次增加1。
如： enum weekday{
Sun;//0
Mon;//1
Tue;
Wed;
Thu;
Fri;
Sat;//6......
}someday0;//定义枚举类型同时声明枚举变量someday0。
enum weekday someday;//先定义枚举类型，再声明枚举变量someday
someday = Mon;//枚举变量someday被定义的枚举常量赋值。
time()和localtime()
****************************************************************************************************************************************************************************************************************
int a[10];//数组定义
void array(int a[]) 等价于void array(int *a)//函数定义
动态内存分配
void *malloc(unsigned size)//函数原型
int *p = NULL;
p = (int*)malloc(sizeof(int));//使用，按字节分配内存，用于数组个数不定时
动态内存分配之后的释放函数
void free(void *p)//函数原型
int *p = NULL;
p = (int*)malloc(sizeof(int));
free(p);//使用
****************************************************************************************************************************************************************************************************************
void *calloc(unsigned n,unsigned size)//函数原型
为n个数组分配size字节大小的内存，并均初始化为0
****************************************************************************************************************************************************************************************************************
void realloc(void* p,unsigned size);//函数原型
重新为指针p所指的内存块分配适合的内存
若指针p指向NULL，则作用与malloc()相同
****************************************************************************************************************************************************************************************************************
EOF(End OF File)
表示文件结束符，用于while循环中，如while(scanf("%d",&n) != EOF),当在控制台输入ctrl+z时结束程序进行
****************************************************************************************************************************************************************************************************************
数据的存储
程序的版本：Debug版本和Release版本
Debug版本即调试版本，包含调试信息，利于去调试程序，无优化。
Release版本即发布版本，对程序进行了多种优化如代码大小和运行速度，便于使用，无调试信息。
数据类型：
类型的意义：确定开辟空间的大小与看待内存空间的视角。
基本类型：
char 字符型//char C语言没有规定是signed char 还是unsigned char 类型，由具体的编译器决定，多数编译器默认为 signed char类型
short 短整型
int 整型//int C语言规定为signed int类型
long 长整型
long long 更长的整型
float 单精度浮点型
double 双精度浮点型
整形家族：
char
unsigned char 0~255（2^8-1）
signed char -128~127
short
unsigned short int
signed short int
int
unsigned int 0~4,294,967,295（2^32-1）
signed int(默认) -2,147,483,648~2,147,483,647
long
unsigned long int
signed long int
浮点家族：
float
double
构造类型(自定义类型)：
数组类型 a[]
结构体类型 struct
枚举类型 enum
联合类型 union
指针类型：
int *p
float *p
double *p
char *p
void *p
空类型：函数返回，函数参数，指针
数据的截断与整型提升（指不同的数据类型之间 ）：
如：int a = 10;
char ch = 10;//10的二进制：00000000 00000000 00000000 00001010 最高位为0，原码反码补码相同
10为整型，占内存的四个字节，由字符类型（一个字节）ch储存时发生截断，只保留最后一个字节（00001010）储存。
ch转化为整型时从前补24个最高位即0，得补码00000000 00000000 00000000 00001010，最高位为0原码反码补码相同，即得原码00000000 00000000 00000000 00001010即10。
堆栈
局部变量储存在栈区，栈区地址从下到上逐渐增大，即上为高地址，下为低地址。栈区先使用高地址，在使用低地址
整型在内存中的储存：
已知数据在内存中以二进制储存，
有符号数的二进制表示方式有三种：原码，反码，补码。，每一种均分为符号位和数值位。
对于正整数：原码，反码，补码三者相同。
对于负整数：
数据储存时的二进制序列最高位为1，而正整数二进制序列最高位为0。
对于signed前缀类型，最高位为符号位无数值表示，而unsigned前缀类型最高位为数值表示。
原码：由数据的数值直接写出的二进制序列，补码取反再加一又得到原码或补码减去1再取反得到原码。
反码：原码符号位（即1）不变，其它位按位取反。
补码：先取反码再+1得到。
如 int a = -10;
内存中存放（16进制）： F6 FF FF FF（此储存为小端字节序）
原码：10000000 00000000 00000000 00001010（四个字节）
反码：11111111 11111111 11111111 11110101
补码：11111111 11111111 11111111 11110110
16进制：FF FF FF F6
int b = 10
内存中存放（16进制）：0a 00 00 00（此储存为小端字节序）
原码：00000000 00000000 00000000 00001010
反码：00000000 00000000 00000000 00001010
补码：00000000 00000000 00000000 00001010
16进制：00 00 00 0a
整型在内存中以补码的形式储存，表示和计算，原因是可以将符号位和数值域统一处理，加法和减法可以统一处理（cpu中只有加法器），原码与补码相互转换运算过程相同，不需要额外硬件电路。
数据数值的二进制的储存形式：大端字节序和小端字节序
如 int a = 0x11223344;//（16进制表示）其中11为高位，44为低位，类比十进制数字
大端字节序：把数据的低位字节序的内容存放在高地址处，高位字节序的内容存放在低地址处。
低地址 11 22 33 44 高地址
小端字节序：把数据的地位字节序的内容存放在低地址处，高位字节序的内容存放在高地址处。
低地址 44 33 22 11 高地址
想知道自己计算机数据的储存形式，可以采用如下代码简单判断：
用字符指针（只看一个字节）指向整型a的第一个字节，若为小端则为（16进制）01 00 00 00，若为大端则为 00 00 00 01。
#include <stdio.h>
int main(){
int a=1;
char *p=(char*)&a;
if(*p==1)
printf("小端\n");
else
printf("大端\n");
return 0;
}
浮点型在内存中的存储：float(四字节)，double（八字节），long double
浮点数在内存中以补码的形式储存。
C语言用二进制储存浮点数的标准：IEEE 754。
任意一个二进制浮点数V均可以化为一个形式：
(-1)^S*M*2^E 其中 ^ 表示指数运算。
S表示符号位，S为0时V为正数，S为1时V为负数。
M表示有效数字，范围大于等于1，小于2。
2^E表示指数位。
例如：9.0（十进制）->1001.0（二进制）->1.001*2^3->0 10000010 00100000000000000000000
5.5（十进制）->101.1（二进制）->1.011*2^2-> 0 10000001 01100000000000000000000
对于double类型：0 00000000000 0000000000000000000000000000000000000000000000000000 首位为符号位，接下来11位存放指数，余下52位存放小数部分。
对于float而言共四个字节32位：0 00000000 00000000000000000000000 首位1或0表示符号位，接着8位存放E即指数（二进制形式），余下的23位储存M（又称小数部分），M不够就补0.
对于1.XXXXXXXXX的二进制有效数字，实际储存时舍去1和小数点，只保留小数点后的0和1，等到取出已经储存好的浮点数时，M部分取出时在开头添加上1和小数点。
对于E指数，看做无符号整型（unsigned int），float中占8位，范围为0~255，考虑到指数E可能为负数，实际储存时要存入正数就需要修正，为指数E加上一个中间值，
127（float）或1023（double）。实际储存的是（E+127）的二进制形式，double占11位范围为0~2047，实际储存的是（E+1023）的二进制形式。
取出时：
E全为0时：
这时浮点数的指数E等于(1-127)或(1-1023)作为真实值，有效数字M不在加上第一位的1，而是还原为0.xxxxxx的小数，以此表示正负0或接近于0很小的数。
00000000八个位为0 ->实际的E的值为0 - 127 == -127，2^(-127)是很小的一个数,正负接近于0。
E全为1时：
这时，如果有效数字M全为0（还原之后为1.000.....），表示无穷大，符号确定正负。
11111111八个位为1 -> 实际的值为255 - 127 == 128，2^(128)是很大的数字 ，表示无穷大。
E不为全0或全1时：（最多）
指数E二进制的计算值减去127（或1023）得到指数位真实值，有效数字M前加上第一位的1，
5.5（十进制）->101.1（二进制）->1.011*2^2-> 0 10000001 01100000000000000000000
***************************************************************************************************************************************************************************************************************
京公网安备 11010502036488号