C语言

自定义函数
（1）在函数使用之前定义函数
（2）先声明这个函数，然后使用，使用的代码后面定义这个函数

include <stdio.h>

void syahello(){
println("helloo");
}

int main(){
sayhello(); // 调用的函数要提前写出来，如果要写在后面，需要先在前面声明
}

void syahello(); //提前声明，没有实现
int main(){
sayhello(); // 调用的函数要提前写出来，如果要写在后面，需要先在前面声明
}
void syahello(){
println("helloo");
}

mytest1(); //如果函数没有明确标明函数的返回值类型，则默认为返回int（不要这样写）
print("%d ",mytest1());

2.形参和实参是值传递v，是单向传递，只能由实参传递给形参，不能由形参传递给实参
入股哦函数的参数是数组，则可以通过形参修改实参的值

void testarr(char s[]){
s[0] = 'a';
s[1]='b';
}

int main(){
char chs[100] = "hello world"
testarr(chs);
printf("%d",chs); // 数组变为abllo world
}

void mergearr(char arr1[],char arr2[]){
int len1 = 0;
while(arr1[len1++]);
len1--; // 记录数组一的长度

int len2=0;
while(arrp[len2+1]);
len2--;

int i;
for(i=0;i<len2;i++){
	arr1[len1+i] = arr2[i];
}

}

int main(){
char arr1[100]="asdad";
char arr2[100]="1111";
mergearr(arr1,arr2);
printf("%s ",arr1); // 发现数组2已经合并了
printf("%s ",arr2);
}

二. 多文件编译

<stdio.h> : 尖括号表示文件在系统路径中
"abc/myhead.h"：表示abc目录下的myhead.h

myhead.h:

define MAX 300 // #define就是简单的字符串替换

main.c:

include <stdio.h>

include "abc/myhead.h"

int main(){
int c = MAX;
printf("%d",c)
}

三. 指针
计算机内存的最小单位使BYTE
每个BYTE的内存都有一个唯一的内存编号，这个编号就是内存地址
编号在32为系统下是一个32位的整数，编号在64位系统下是一个64位的整数

用指针型变量来表示这个内存地址号。
：指针变量指向的内容。指针型变量不能向int变量一样显示的声明出来，只能用变量名来声明一个int值，则该变量是指针型变量，*变量名是一个int值
&：得到变量对应的指针变量（内存地址）

void main{
int a=3;
int *p; // *p是int型变量，p是指针型变量
p = &a; // 指针型变量就是内存号，所以&符号取得a的内存号
int b = *p;
printf("%d",b);
*p = 100;
printf("%d",a) // 通过内存号修改变量值

char chs[10];
printf("%u,%u,%u,%u",chs,chs[0],chs[1],chs[2])  // %u：unsigned无符号整形，数组首地址，第一个元素的地址，第二个元素的地址

int ints[10];
printf("%u,%u,%u,%u",ints,ints[0],ints[1],ints[2])  // %u：unsigned无符号整形，数组首地址，第一个元素

}

无类型指针：
void *p：说明p只是一个指针比那辆，而不去指向任何一个变量

include <stdio.h>

void main(){
int a = 100;
int *p; // int *p是声明写法：整体代表一个地址号，这个地址号上存着整数。单独一个p：定义写法，也是内存号
int *q;
p = &a;
//int p = 1; // p指向的地址号是1（声明+定义写在了一起）
printf("%u",p); // 3852910012
printf("%u",p); // 100
printf("%d ",sizeof(p)); //8：指针在64位系统下就是一个64位的整数，所以占8字节。无论指针指向什么类型的数据，64位下都占8字节
printf("%d ",sizeof(a)); //4：int型占4字节

int *p;  //声明指针，没有指向，就是野指针。野指针使导致程序崩溃的主要原因
*p = 1; // 为地址上赋值1，会出现错误  [1]    6285 segmentation fault (core dumped)  a.out

int *p = NULL; // 空指针使合法的，野指针是非法的

}

/** int *p 与p一致
*/

include <stdio.h>

void main(){
int a =100;
int p = &a;
int q;
q = &a;
printf("p:%u,q:%u ",p,q); // p:2373644580,q:2373644580
printf("p:%d,q:%d",p,q);// p:100,q:100
}

指针的兼容性

include <stdio.h>

void main(){
int a = 0X1013;
char b = 13;

int *p;
p=&a;
printf("%x",*p);     // 1013

p=&b;				// 10130d  用int指针指向char类型变量，因为int指针指向了连续4字节的地址，所以除了1013外后面还有3个字节的数据当做一体来指向
printf("%x",*p);     


int *q;
char buf[] = {0x12,0x34,0x56,0x78,0x90,6,7,8,9,10};
q = buf;
printf("%x
",*q);

//指针不兼容的情况
float i = 3.14;
int *p = &i;
printf("%d",*p);  // 此时并不能打印出3，这就是指针类型不兼容

}

指向常量的指针和指针常量
void main(){
int a = 100;
const int p = &a; // 指向常量的指针只能读内存，但可以改变指向
printf("%d ",p); // 100

int *const q = &a; // 常量指针可以读写指向的内存，但不能改变指向
q = 200;
printf("%d ",q); //200
printf("%d ",a); //200
}
数组与指针
void printarr(char s[]){
int i;
for(i=0;i<10;i++){
printf("s[%d] ", %d);
}
}
void main(){
char buf[10] = {1,2,3,4,5,6,7,8,9,0};
char *p = buf;
char *p1 = &buf[0];
char *p2 = &buf[1];

printf("%d ", *p); //1
printf("%d ", *p1); //1
printf("%d ", *p2); //2

p2 ++; // 指针是地址号，p+1
*p2 = 100; // 更改为100
printarr(buf);
}

ip地址在网络中不是以字符串传输，字符串太长，而是以DWORD传输(4字节)，飙戏那位一个int数值

include<stdio.h>

void change2char(int i){
unsigned char p = &i;
printf("%d.%d.%d.%d",p,(p+1),(p+2),(p+3));
}
void main(){
int a = 0;
unsigned char p1 = &a; // 无符号使得最大值为255
*p1 = 192;
/**(p+1) = 168;
(p+2) = 0;
(p+3) = 1;/
p1++;
p1 = 168;
p1++;
p1=0;
p1++;
p1=1;
printf("ip:%d",ip);
// a已经被改变为一个ip地址
change2char(a);
}

int s2ip(char s[]){
int a = 0;
int b = 0;
int c = 0;
int d = 0;
sscanf(s,"%d.%d.%d.%d",&a,&b,&c,&d);
printf("a=%d,b=%d,c=%d,d=%d ", a,b,c,d);
int ip=0;
char *p = &ip;
p++;
*p = a;
p++;
*p=b;
p++;
*p=c;
p++;
*p=d;
}
void main(){
char s[] = "192.168.0.1";
printf("%d ", s);
}

eg:用指针合并数组
void main(){
char s1[] = "hello";
char s2[]="world";
char p1 = &s1;
char p2 = s2;
while(p1){ //p1指向的元素为0时跳出循环
p1 ++;
}
while(*p2){
*p1++ = *p2++; // 先指向，后指针移位
}

}

指针运算不是简单地数值加减法，而是指针指向的数据类型在内存中所占字节数为倍数的运算
void main(){
int buf[10];
int *p = buf;
printf("%d ", p); //-1670667696
p+=3;// 实际上内存地址好涨了12
printf("%d ", p);
p = (int)p+3; // 此时把内存地址号强制转为int型，此后加3就是数值运算：-1670667684
printf("%d ", p); // -1670667681

char *p2 = buf;
p2 += 4;
printf("%d
", *p2);  // 0

short *pp1 = &buf[1];
short *pp2 = &buf[3];
printf("%d
", pp2 - pp1);   // buf3和buf1差8个字节，但是一个short指针变量指向2个字节的连续块，所以值位4

}

二维数组的指针
void main(){
int buf[2][3] arr = {{1,2,3},{4,5,6}};
// int p[3] ; //定义一个指针数组
int (p)[3]; // 定义了一个指针，指向int[3]这种数据类型，也叫作指向二维数组的指针
printf("%d ",sizeof(p)) ; //8 因为指针在64位系统都是占8位
printf("%d,%d ",p,p+1); //相差12字节

p = buf; //p指向了二维数组的第一行
p++; //p指向了二维数组的第二行

// 指针遍历
int i,j;
for(i=0;i<2;i++){
	for(j=0;j<3;j++){
		//printf("%d
", *(*(p+i)));   //打印结果1，1，1,4，4，4
		printf("%d
", *(*(p+i)+j);  // 遍历每个元素
		printf("%d
", p[i][j]);  // 每个元素,与上面相等
	}
}

}

指针作为函数参数
void test(int n){
n++;
}
void test2(int p){
(p)++;
}
void main(){
int i =100;
test(i); //c语言是值传递，所以普通函数参数的改变是不能传回给参数的，但如果参数是地址，改变地址上的值
printf("%d ", i);

test2(&i);
printf("%d
", i);

}

一维数组作为参数的指针
void swap(int *a,int *b){
int tmp = *a;
*a = *b;
*b = tmp;
}
// 当数组名作为参数传递时，数组名解析为数组首地址指针，所以多写为void setarray(int *buf)
void setarray(int buf[]){
printf("占%d位 ", sizeof(buf)); //8：64位系统指针占8字节
buf[0] = 100;
buf[1]=200;
int i;
for(i=0;i<10;i++){
printf("%d ", buf[i]);
}
}
void setarray(int *buf,int n){ // n为数组的长度
buf[0] = 100;
buf[1]=200;
int i;
for(i=0;i<n;i++){
printf("%d ", buf[i]);
}
}
void main(){
int a = 10;
int b = 20;
swap(&a,&b);
printf("%d,%d ", a,b);

// 因为数组名是数组的首地址，所以数组名作为行参传递的时候，就相当于传递的指针
int buf[]= {1,2,3,4,5,6,7,8,9,0};
printf("%d
", sizeof(buf)); //40
setarray(buf,sizeof(buf)/sizeof(int));  // 数组长度写成sizeof(buf)/sizeof(type)

}

二维数组的指针作为函数参数
void printarr2(const int (*p)[4],int m,int n){//mn分别是二维数组的第一个和第二个角标。通过const标识，保护函数不会改变数组中的值
int i,j;
for(i=0;i<m;i++){
for(j=0;j<n;j++){
printf("p[%d][%d] = %d ", i,j,p[i][j]);
}
}
}
int main{
int buf[][4] = {{1,2,3,4},{5,6,7,8}};
printarr2(buf,sizeof(buf)/sizeof(buf[0]),sizeof(buf[0])/sizeof(int));
return 1;
} 33 min 18 s
--------------计算二维数组每一列的平均值----------------

include<stdio.h>

void main(){
int buf[2][4] = {{1,2,3,4},{5,6,7,8}};
for(int i=0;i<4;i++){
int sum = 0;
for (int j = 0; j < 2;j++)
{
sum += buf[j][i];
}
printf("%d ", sum);
}
}

函数指针
函数也有地址，这个地址存放的是代码
int getmax(int x, int y){ // 也可以写为int getmax(int x, int y) 意思一样，函数名同数组名一样，都是即表示本身，又表示指向自身开头的指针
return x>y?x:y;
}
int getmin(int x, int y){
return x<y?x:y;
}
int main(){
int (p)(int,int) ; //定义一个指针p指向函数，该函数反获知是int，2个输入参数是(int,int)
int fun = 0;
scanf("%d",&fun);
if(fun==1){
p = getmax; //函数名就是指针
}else{
p = getmin; //函数名就是指针
}
int i = p(2,4); // 通过函数指针调用函数
printf("%d ", i);
}

31min
函数指针是指向函数的指针变量
void p(int,char) // 定义一个函数，函数名为p，参数为int和char类型，返回值为void类型
void (p)(int,char) // 定义一个指针，该指针指向函数。返回值为void, 参数为int和char类型

将一块内存初始化为0最常见的方法：memset(buf,值，size(buf))：要设置的内存地址，设置的值，内存大小(单位字节)
memcpy(buf2,buf1,sizeof(buf1))：将buf1的内容全部拷贝到buf2
memmove (buf2,buf1,sizeof(buf1));

include <string.h>

include <stdio.h>

void main(){
int buf[10] = {1};
memset (buf,0,sizeof(buf));

int buf2[] = {1,2,3,4,5,6,7,8,9,0};
int buf3[];
memcpy(buf3,buf2,sizeof(buf2));
for (int i = 0; i < 10; i++)
{
	printf("%d
", buf2[i]);
}

}

指针数组与多级指针
int main(){
int *a[10]; //一个数组，数组内有10个元素，64为系统中，指针站8字节，64位
printf("%d,%d ", sizeof(a),sizeof(a[0])); // 40,8
short *b[10];
printf("%d,%d ", sizeof(b),sizeof(b[0])); // 40,8
}

int main(){
int a = 10;
int p = &a;
int **pp = &p; // pp指向p的地址
**pp= 100; //修改a的值如果p=100，则是把p这个地址号改为100
printf("a=%d ",a);
int ppp = &pp;
a = ppp;
println("%d,%d",ppp,&pp); // 三级指针的内容=二级指针的地址
}

指针完成字符串操作
int mian(){
char buf[100] = "hello world";
char *p = buf;
p += 5;
*p = 'c';
printf("%s ", buf); // hellocworld
return 1;
}

如果字符串中包含0字符，则打印到此位置就结束了。泪库里面的函数都是有识别字符串结尾的

c语言主函数也是有输入参数的，而且有2个，第一个表示输入参数的个数，第二个是一个指针数组，每个指针指向char类型
输入参数个数：永远大于1，因为程序名本身作为一个输入参数
指针数组：这个指针数组的长度是第一个参数，每个元素指向一个输入参数
int main(int argc,char *args[]){
if(argc!=4){
printf("请输入完整的数学表达式，以空格分开" );
return 0;
}

int a = atoi(args[1]);
int b = atoi(args[3]);

switch(args[2][0]){
	case '+':
		printf("%d
", a+b);
		break;
	case '-':
		printf("%d
", a-b);
		break;
	case '*':
		printf("%d
", a*b);
		break;
	case '/':
		if(b){
			printf("%d
", a/b);
		}
		break;
}
return 0;

}

内存管理

作用域
（1）文件作用域：全局变量，定义在函数外面的变量
int a=10;
void main(){
int a = 20; // 函数内部可以再次定义和全局变量同名的变量，定以后a为20，没有定义为10
printf("%d ", a);
}
（2）extern关键字

include "c.h" #在这个文件中定义了age=10

extern int age ;// 该变量在其他文件中定义了，连接时使用就可以了。这个另一个文件需要时.c文件，不能是.h文件。gcc编译时后面加上两个文件名
setage(int n){
age = n;
}
getage(){
printf("%d ", age);
}
void main(){
setage(11);
getage(); // 11
}
（3）auto自动变量：不写auto，就默认为auto变量
（4）register 变量：建议变量放到空闲的寄存器中
寄存器变量不能取地址操作
（5）static 变量：只初始化一次，程序运行期间一直存在。static只是增大了变量的存在时间，却没增大变量的作用域
一旦全局变量被static修饰，则这个变量的作用域被限制在该文件内部，其他文件不能用extern使用
void mystatic(){
static int a = 0; // 不加static，循环打印每次打印都是0，加上static每次打印+1
printf("%d ", a);
a++;
}
void main(){
for (int i = 0; i < 10; ++i)
{
mystatic();
}
}

c语言中，函数都是全局的。
（1）如果函数前面加了static，则函数被限制在文件内部使用
（2）函数前面加不加extern一样。而变量前面的extern是可以省略的，比如：int a; 如果其他文件中定义了int a=10，则此处的变量是声明，如果其他文件中没有定义a，则此处是定义
（此处也是说明c语言并不严谨）
c语言内存管理
程序在内存中分为4个区域：
（1）堆
（2）栈：此部分的内存表现为先进后出。所有自动变量，函数行参都有编译器自动放到栈中。当一个自动变量超出其作用域时，自动从栈中弹出。先进入栈中的变量放到大内存号中
（3）静态区：所有的全局变量，以及程序中的静态变量都存储在静态区
（4）代码区：程序在被操作系统加载到内存中时，所有可执行代码加载到代码段，这块内存不能再程序运行期间修改
int c= 0;
void main(){
int a=1;
int b=2;
static int d = 3;
printf("%d,%d,%d,%d,%d ", &a,&b,&c,&d,main); // 1321929276,1321929272,6295612,6295604,4195632
}
上述程序的a和b在栈区，所以地址号紧挨着：1321929276,1321929272 发现a所在的内存号在高位。
c和d在静态区：地址号紧挨着
main在代码段

二进制文件读写

fscanf：读文件时，可以根据固定格式读取
fprintf：写文件，和printf一样，可以定义输出格式，只是输出到文件中

include <stdio.h>

include <string.h>

include <stdlib.h>

void main(){
FILE *p = fopen("a.txt","r");
while(!feof(p)){
int a,b;
fscanf(p,"%d + %d =",&a,&b); //文本格式为a + b =,从中截取a,b
printf("%d,%d",a,b);
}
}

void main(){
FILE *p = fopen("a.txt","w");
char buf[100] = "hello world fuck ";
int a=1,b=2;
fprintf(p,"%s,%d,%d",buf,a,b);
fclose(p);
}

fread与fwrite读写二进制文件
上面的函数只能操作字符文件,字符文件每次只能读一行
void main(){
FILE *p = fopen("a.txt","rb"); // 以二进制方式读取
char buf[100] = {0};
fread(buf,sizeof(char),1,p); // 读取字节的缓冲区，读取单位，一次读取几个单位，文件指针
printf("%s ", buf);
fclose(p);
}

int main(){
int a = 10;
int p = &a;
int **pp = &p; // pp指向p的地址
**pp= 100; //修改a的值如果p=100，则是把p这个地址号改为100. pp就是地址号的内容相当于改变p的内容，**pp就是地址号中记录的地址号的内容
printf("a=%d ",a);
int ppp = &pp;
a = ppp;
println("%d,%d",ppp,&pp); // 三级指针的内容=二级指针的地址
}

指针完成字符串操作
int mian(){
char buf[100] = "hello world";
char *p = buf;
p += 5;
*p = 'c';
printf("%s ", buf); // hellocworld
return 1;
}

如果字符串中包含0字符，则打印到此位置就结束了。泪库里面的函数都是有识别字符串结尾的

int a = atoi(args[1]);
int b = atoi(args[3]);

switch(args[2][0]){
	case '+':
		printf("%d
", a+b);
	case '-':
		printf("%d
", a-b);
	case '*':
		printf("%d
", a*b);
	case '/':
		if(b){
			printf("%d
", a/b);
		}
}
return 0;

}

栈：不会很大，栈空间是操作系统为每个程序固定分配的大小以k为单位。栈空间是操作系统为每个程序固定分配的大
每个线程都有自己的栈
int main(){
char array[102410241024] = {0}; //定义一个超大的数组就会栈溢出
return 0;
}

堆：堆没有大小限制，只是无力限制。但是堆内存不能由编译器自动释放

include <stdlib.h>

int main(){
int p = malloc(sizeof(int)10); // 在堆中申请了10个int的大小
char p2 = malloc(sizeof(char)10);

memset(p,0,sizeof(int)*10);  // malloc申请的堆内存 ，在代码的操作上相当于数组
for(int i=0;i<10;i++){ 
	p[i] = i;  // 操纵数组
}

free(p) ; // 释放通过malloc申请的堆内存
free(p2);

}

不能将一个栈变量的地址作为函数的返回值，e因为函数结束后，栈变量被释放
eg: int *geta(){
int a = 10;
return &a;
}
但是可以把堆变量的地址作为函数返回值返回
int *geta(){
int *p = malloc(sizeof(int));
return p;
}

int main(){
int *p = geta();
malloc(p);
}

一个经典的错误模型：
void getheap(int p){
p = malloc(sizeof(int)10);
}
void main(){
int *p = NULL;
getheap(p); // 此处是错误的，因为函数的参数是值传递，虽然语义是getheap(p),但是mallo的内存地址只是付给了函数的形参，函数退出后，形参的值并不能传递给实参(指针的值也一样不能传递)，导致p还是空指针，下面的p[0]=1发生空指针异常
p[0] = 1;
printf("%d ", p[0]);
free(p);
}
经典的正确模型：二级指针作为形参，对上面错误模型的改写
void getheap(int **p){
p = malloc(sizeof(int)10); // 所致地址号的内容，就是指以及指针的内容
}
void main(){
int *p = NULL;
getheap(&p); // 此处是错误的，因为函数的参数是值传递，虽然语义是getheap(p),但是mallo的内存地址只是付给了函数的形参，函数退出后，形参的值并不能传递给实参(指针的值也一样不能传递)，导致p还是空指针，下面的p[0]=1发生空指针异常
p[0] = 1;
printf("%d ", p[0]);
free(p);
}

不能用变量声明一个数组，eg:int arr[i], 如果申请内存的大小靠程序运行期间决定，那么就要使用 malloc(sizeof(int)*i),要记得free
代码区和静态区的大小都是固定的，静态区是编译器根据代码提前申请的。堆和栈所占大小是动态，但是栈有一个操作系统规定的栈上线

cd /proc // 每个进程号都是一个文件
cd pid
cat maps // 查看内存映射，这里列出了代码段，堆，栈，静态区的使用情况（栈的预设范围）

堆的分配和
操作系统分配内存的单位不是字节，而是页。cat smps之后，发现堆有个项是内存页大小：4k。页太大，浪费的内存空间太大，但操作系统维护起来很简单，因为不用频繁的申请释放内存

malloc申请的堆内存上会存在旧数据，所以申请后需要用memset清空： memset(p,p,sizeof(int)*10)
这两句话的简写就是calloc，这样内存上全部是0
int main(){
char p = calloc(10,sizeof(char)); // 申请大小是10sizeof(char)
}
relloc用于扩展已经申请的堆内存，在原有内存上，增加连续的内存，如果没有连续空间可扩展，则会新分配一个连续空间，将原有内存拷贝到新空间，然后释放原有内存
但是relloc只申请，不打扫（内存中有旧数据）

rello(p,新的内存大小),.如果p为NULL，则realloc等于malloc，不指定分配空间的起始位置
void main(){
char *p1 = calloc(10,sizeof(char));
char *p2 = realloc(p1,5); // p1指向的地址变为5
// realloc(NULL,5) = malloc(5)
}

结构体：

include <string.h>

struct student{
char name[100];
int age;
int sex;
}; // 声明一个结构体

void main(){
struct student st; // 定义了一个结构体的变量，名字叫st
//struct student st2 = {.name="周杰伦",.sex=0}; 结构体中通过.来给属性赋值
struct student st3 = {0}; // 定义结构体变量，并把结构体变量的所有属性设置为0
struct student st4;
memset(&st,0,sizeof(st)); // 结构体变量初始化
st.age = 25;
st.sex = 1;
strcpy(st.name,"刘德华");

printf("%d
", st.age );

}

结构体的内存对齐模式：
结构体在内存中是一个矩形，而不是一个不规则形状，以结构体中占地最大的元素对齐。而且不同类型的属性要跨偶数个字节
struct A
{
int a; // 4字节
char b; // 以4字节对齐
}; // 总共8字节

struct B
{
char a; // 1个字节
short b; // short不同于char类型，所以要夸2字节，从第3个字节开始对齐，占2个字节
char c; // 占1个字节
int d; // 第二个8字节对齐行
long long e; // 8个字节，占地最多的属性，所以其他属性以8字节对齐；
};

printf("%d ", sizeof(B));

结构体成员的位字段
struct A
{
char a:2; // char占1个字节，但是这样声明的结构体中的a字段，只有前2bit能通过结构体使用，但值得注意的是此时整个结构体仍然占1个字节而不是2bit
};
void main(){
struct A a;
a.a = 3; //二进制11，有符号char，所以会打印-1
printf("%d ", );
}

struct B
{
char a:2;
unsigned char b:4;
char c:1;
};

printf("%d ", sizeof(struct B));

指针操作结构体不了的内存地址
struct H
{
char a; // 1个字节，但是后三个字节由于结构体对齐而操作不了
int b;
};

void mian(){
struct H h = {1,2};
char *p1 = &h;
p1 ++;
* p1 = 4;
*(++p1) = 5;
*(++p1) = 6;
*(++p1) = 7;
printf("%d ", &h+4);
}

结构体模仿数组（用字段地址连续的结构体成员）
struct D
{
char a;
char b;
char c;
};

void main(){
struct G g;
char *p = &g;
p[0] = 'a';
p[1] = 'b';
p[2] = 'c';
printf("%d,%d,%d ", g.a,g.b,g.c);
}

结构体数组
struct People
{
int age;
char name[10];
};

void main(){
struct People p[3] = {{11,"aa"},{22,"bb"},{33,"cc"}};
for (int i = 0; i < 3; ++i)
{
printf("%d,%s ", p[i].age,p[i].name);
}
}

结构体可以变相实现数组的赋值
struct A
{
char arr[10];
};

void main(){
struct A a1 = {"hello"};
struct A a2= {0};
a2 = a1;
printf("%s ", a2.arr);
}

结构体的嵌套
struct A{
char a;
char b;
}
struct{
struct A a;
int b;
} // 一共占8字节

结构体赋值，其实就是结构体之间内存的拷贝
struct strss
{
char s[100];
};
void main(){
struct strss s1,s2;
strcpy(s1.s,"hello");
// s2 =s1; 这句话等同于下面的memcpy,结构体是变量，所以可以赋值
memcpy(&s2,&s1,sizeof(s1));
printf("%s ", s2.s);
}

指向结构体的指针操作结构体
void main(){
struct A a;
struct A p = &a;
// (p).a = 10; 这样写是对的，但是太麻烦，没人这么写
p -> a = 10; // 用->代表结构体的一个成员
}

指向结构体数组的指针
<string.h><stdlib.h>
void main(){
struct A *p ;

/* struct A array[10] = {0};
p =  array;  // 指针指向数组首地址 */

//也可以在堆中创建结构体
p = malloc(sizeof(struct A) * 10);
memset(p,0,sizeof(struct A) * 10)
struct A *array = p;

p->a = 10;
p->b = 11;

p++;  // p已经变化了，所以free时要从头free，就是array。如果free(p)，就从当前p的位置往下数10个字节，这样就free了不属于结构体数组的内存，运行报错
p->a = 3
p->b = 4;

for (int i = 0; i < 10; ++i)
{
	printf("%d,%d
", array[i].a,array[i].b);
}

free(array);

}

结构体作为函数参数时，尽量使用指针传递参数，不要直接使用结构体作为形参
因为结构体和int等变量一样，作为参数传递时是值拷贝传递，如果传递指针，则函数只需要拷贝8字节的地址号，而且如果函数想要操作结构体的话，也只能通过指针进行参数操作

void setname(struct student *a,int age){
*a->age = age;
}

四。联合体

联合体所占内存的大小等于联合体中最长属性所占狄村的大小，联合体的所有属性公用一块内存地址
union A{
int a;
char b;
}
void main(){
union A a;
a.a = 0X12345678;
printf("%d ", sizeof(union A)); // 4 ,最长的int属性，栈4字节
printf("%p,%p ", &a.a,&a.b); // 2个地址一样
printf("%d,%d ", a.a,a.b); // 12345678, 78
}

一个经典的错误写法
union A{
int a;
char *b;
}
void main(){
union A a;
a.b = malloc(100);
a.a = 100;
// 此时改变了a的值就是改变了b的值，下面free的地址就不再是原来的地址，会报错
free(b)
}
所以：如果一个联合体中包含了含有指针变量，那么一定要在使用完这个指针后，病free掉它，才能使用联合体的其它成员

五。枚举

枚举是一个int常亮，不能改变他的值
美剧中的每个量都相当于#define x 整数
//#define red 0 相当于下面的枚举定义
//#define black 1
//#define yellow 2
enum A{
red,black,yellow
};
void main(){
printf("%f ", red); // 打印0
}

六。typedef

typedef char BYTE; 自定义一个BYTE类型，作为char类型
相当于

define BYTE char

typedef 通常用于简化结构体变量的名字为一个简短的名字
struct A{
int a;
}
typedef struct abc A; // 本来声明变量时需要struct A a, 现在只需要abc A即可
typedef定义结构体的简写形式
typedef struct A{
int a;
}abc; // 张扬相当于上面2句话的简写, A也可以不写形成第三种写法，如下

typedef struct {
int a;
}abc;

typedef定义函数指针

include <string.h>

include <stdio.h>

void *mystrcat (char *s1,char *s2){
strcat(s1,s2);
}
// 定义一个函数，有三个参数，函数指针，形参1，形参2
void *test(void (p)(char *,char *),char *s1,char s2){//函数指针p,返回值是void *,形参有两个，都是char *类型
p(s1,s2);
}

// 上面的test函数太复杂，因为参数里包含一个函数指针
typedef void (MYSTRCAT)(char *,char *) // 把一个函数指针定义为MYSTRCAT类型

void main(){
MYSTRCAT aa[10];
char s1[100] = "hello";
char s2[5] = "world";
test(mystrcat,s1,s2);
printf("%s ", s1);
}

七。文件操作
写文件

include <stdio.h>

int main(){
FILE *p = fopen("aaa.txt","w");
fputs("hello world ",p);
fclose(p);
return 0;
}

读文件

include <stdio.h>

include <stdlib.h>

int main(){
char s[1024] = {0};
FILE *p = fopen("aaa.txt","r");
while(!feof(p)){ // 如果文件已经到最后，则文件返回真)
memset(s,0,sizeof(s));
fgets(s,sizeof(s),p); // 从p位置读取10个字节
printf("%s", s);
};

    fclose(p);
    return 0;

}

如果文件不存在，则新建文件，如果存在就追加文件内容
fopen("aaa.txt","a");

C语言

include <stdio.h>

define MAX 300 // #define就是简单的字符串替换

include <stdio.h>

include "abc/myhead.h"

include <stdio.h>

include <stdio.h>

include <stdio.h>

include<stdio.h>

}

}

include<stdio.h>

31min 函数指针是指向函数的指针变量 void p(int,char) // 定义一个函数，函数名为p，参数为int和char类型，返回值为void类型 void (p)(int,char) // 定义一个指针，该指针指向函数。返回值为void, 参数为int和char类型

include <string.h>

include <stdio.h>

内存管理

include "c.h" #在这个文件中定义了age=10

include <stdio.h>

include <string.h>

include <stdlib.h>

include <stdlib.h>

include <string.h>

define BYTE char

include <string.h>

include <stdio.h>

include <stdio.h>

include <stdio.h>

include <stdlib.h>

31min
函数指针是指向函数的指针变量
void p(int,char) // 定义一个函数，函数名为p，参数为int和char类型，返回值为void类型
void (p)(int,char) // 定义一个指针，该指针指向函数。返回值为void, 参数为int和char类型