预备知识
1.所有的指针变量只占4个子节 用第一个字节的地址表示整个变量的地址
//1.cpp 所有的指针变量只占4个子节 用第一个字节的地址表示整个变量的地址
# include <stdio.h> int main(void)
{
double * p;
double x = 66.6; p = &x; //x占8个字节 1个字节是8位， 1个字节一个地址, p中只存放一个地址，通常是第一个字节的地址
// 一个变量占好多好多字节，但是我们通常用一个字节的地址来表示整体的地址，即首地址来表示它 double arr[] = {1.1, 2.2, 3.3};
double * q;
q = &arr[];
printf("%p\n", q); //%p实际就是以十六进制输出
//[Out]:
//0019FF1C
//0019FF24
q = &arr[];
printf("%p\n", q); // 一个指针变量，无论它指向的变量占多少个字节，它本身的大小都是一样的，只占4个字节 return ;
}
2.如何通过函数修改实参的值
//3.cpp 如何通过函数修改实参的值
# include <stdio.h> //void f(int *q);
void f(int **q); int main(void)
{
int i = ;
int * p = &i; //等价于int *p; p = &i; printf("%p\n", p);
f(&p); // 无论参数是什么样的变量，要改变它的值，只需要改变它的地址即可
printf("%p\n", p); return ; } //void f(int * q)
//{
// q = (int *)0xFFFFFFFF;
//}
//[Out]:
//0019FF3C
//0019FF3C 并未改变主函数的值，因为没有修改它的地址 void f(int ** q)
{
*q = (int *)0xFFFFFFFF;
}
//0019FF3C
//FFFFFFFF
//以上写法程序不安全，不能写成**的方式来更改main函数中的值
一、结构体
1.为什么会出现结构体
为了表示一些复杂的数据，而普通的基本类型变量无法满足要求(实际上就是java/python中的类)
如: 仅仅用int age; str name 无法区分表示多个学生的整体特征
结构体中没有方法，模拟一个事物模拟得不是很彻底；但好处在于，编写程序时，是以算法为核心的。
学数据结构，算法在c语言/面向过程的语言中，是最好的，但是在java这种面向对象的语言中，算法就不是特别核心了。
2.什么叫结构体
结构体是用户根据实际需要，自己定义的复合数据类型
3.如何使用结构体
//struct_1.cpp 结构体的使用概述
# include <stdio.h>
# include <string.h> struct Student //结构体是数据类型，而不是变量，定义变量一定要分配内存，
//struct Student是一个整体，是一个模型,有三个成员(不是属性,java/python中才叫属性);但是定义结构体并没有分配内存，只是定义了一个新的数据类型
{
int sid;
char name[];
int age; }; //分号不能省 int main(void)
{
struct Student st = {, "zhangsan", }; //用struct Student 这个数据类型，定义了一个变量st，赋值;struct Student一定要整体写
printf("%d %s %d\n", st.sid, st.name, st.age); // 第一次编写时一定要编译，不然VC6不会提示，编译了一次以后就可以提示了
//[Out]:
//1000 zhangsan 20
// st.sid = 99; //error, c++中不能这样赋值，java/python才可以，必须按照上面的写法
strcpy(st.name, "lisi"); // strcpy实际上就是复制的作用，在开头要添加上# include <string.h>
st.age = ;
printf("%d %s %d\n", st.sid, st.name, st.age);
//[Out[
//1000 zhangsan 20
//1000 lisi 22
// printf("%d %s %d\n", st); //error
return ;
}
//struct_2.cpp 结构体的两种使用方式
# include <stdio.h> int main(void)
{
struct Student st = {, "zhangsan", };
//st.sid = 99; // 如何使用结构体变量？第一种方式，很少使用，因为不会定义很多变量的名字
struct Student * pst = &st; // 第二种方式是最常用的: 定义一个指针变量*pst,存放struct Student这种变量地址，
// struct Student这个变量占多少个字节? int sid --4 ; char name[200] --200 ; int age --4; 共计208个(理论上，实际上很可能不是)
//pst = &st; //pst存放st的地址，则pst指向st了，*pst就是st了
pst->sid = ; //pst->sid 等价于(*pst).sid, 没有什么为什么，是规定，只需要记住；而(*pst).sid等价于st.sid, 所以pst->sid 等价于st.sid }
3.1.两种方式:
struct Student st = {1000, "zhangsan", 20};
struct Student * pst = &st;
3.1.1. st.sid
3.1.2.pst->sid
//pst所指向的结构体变量中，有sid这个成员(最终表示的就是sid这个成员)
4.注意事项:
4.1.结构体变量不能加减乘除，但可以相互赋值；
4.2.普通结构体变量和结构体指针变量作为函数传参的问题
//struct_3.cpp 结构体变量
# include <stdio.h>
# include <string.h> struct Student
{
int sid;
char name[];
int age; }; void f(struct Student * pst); //前缀声明
void g(struct Student st);
void g2(struct Student * pst); int main(void)
{
struct Student st; f(&st);
//printf("%d %s %d\n", st.sid, st.name, st.age);
g(st); // 通过一个函数实现输出，而不是直接输出。将208个字节赋值给另一个函数，这种方式速度慢，浪费空间,不推荐
g(&st); // 结果输出速度快很多 return ;
}
//[Out]:99 zhangsan 22 void g(struct Student st)
{
printf("%d %s %d\n", st.sid, st.name, st.age);
} void g2(struct Student *pst)
{
printf("%d %s %d\n", pst->sid, pst->name, pst->age); // 通过指针只花了4个字节的空间，也能够实现 } void f(struct Student * pst) // 将st的地址发送给了pst，不是*pst
{
(*pst).sid = ; // 普通变量使用.来调用
strcpy(pst->name, "zhangsan"); // 指针变量用->来调用
pst->age = ;
}
二、动态内存的分配和释放
1.动态构造一维数组
假设动态构造一个int型数组
int *p = (int *) malloc(int len);
1.1. malloc只有一个int型的形参，表示要求系统分配的字节数
1.2.malloc函数的功能是请求系统len个字节的内存空间，如果请求分配成功，则返回第一个字节的地址，如果分配不成功，则返回NULL
1.3.malloc函数能且只能返回第一个字节的地址，所以我们需要把这个无实际意义的第一个字节的地址(俗称干地址)转化为一个有实际意义的地址
因此，malloc前面必须加(数据类型*),表示把这个无实际意义的第一个地址，通过强制类型转换，来告诉编译器，我们返回的第一个类型的地址，它到底是整型地址，还是其他类型的地址，即为前面(int *)类型的含义。
如: int *p = (int *)malloc(50):
表示将系统分配好的50个字节的第一个字节的地址转化为整型地址，更准确的说是把第一个字节的地址转化为4个字节，这样p就指向了第一个的4个字节，
p+1就指向了第2个的4个字节。p[0]就是第一个元素
double *p = (double *)malloc(80);
表示将系统分配好的80个字节的第一个字节的地址转化浮点型地址，更准确的说是把第一个字节的地址转化为8个字节，这样p就指向了第一个的8个字节，
p+1就指向了第2个的8个字节。p+i就指向了第i+1个的8个字节。p[0]就是第一个元素
free(p) 释放p所指向的内存，而不是释放p本身所占用的内存
# include <stdio.h>
# include <malloc.h> int main(void)
{
int a[] = {, , , , };
int len;
printf("请输入你需要分配的数组的长度: len = ");
scanf("%d", &len);
int *pArr = (int *)malloc(sizeof(int) *len); //分配20个字节，逻辑上的效果：pArr指向了前4个字节，pArr +1 指向后4个
// int * 强制转换，malloc只能返回第一个字节地址
//输入4
//[Out]:4 10 // 不需要写死，可以动态的分配内存malloc(sizeof(int) *len) // *pArr = 4; //类似于 a[0]=4;pArr指向前4个字节
// pArr[1] = 10; //类似于a[1]=10;
// printf("%d %d", *pArr, pArr[1]); // 我们可以把pArr当做一个普通数组来使用
for (int i=; i<len; ++i) //退出for循环 int就没有了
scanf("%d", &pArr[i]); for (i=; i<len; ++i) //退出for循环 不能再加int, i还能用 要不然就重复定义了
printf("%d\n", *(pArr+i)); free(pArr); //程序运行中可以释放,把pArr所代表的动态分配的20个字节的内存释放
//输入4
//[Out]:
// 1 2 3 4
// 1
// 2
// 3
// return ;
}
2.跨函数使用内存：只能通过动态来实现
//test1、下程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是: //整型单元-》合法变量
//A)
main()
{
int *p; //主函数的指针变量p，此时为p中为一个垃圾数字
fun(p); //通过调用p，使它指向一个合法的整型变量，但是直接调用p，是无法改变数值的 // 参考笔记1-> 如何通过被调函数，修改主调函数中普通变量的值: 1)实参为相关变量的地址：&i
...
}
int fun(int *p)
{
int s;
p=&s;
} //B)
main()
{
int *p;
fun(&p); // 参考笔记1-> 如何通过被调函数，修改主调函数中普通变量的值: 1)实参为相关变量的地址：&i
...
}
int fun(int **q) // 此时*q即为p,将p的地址发送给q，类型一致 参考笔记1-> 如何通过被调函数，修改主调函数中普通变量的值: 2)形参为以该变量的类型为类型的指针变量：*p
{
int s;
*q=&s; // 即为p=&s;参考笔记1-> 如何通过被调函数，修改主调函数中普通变量的值: 1)实参为相关变量的地址：p=&i } //执行完此行代码时，p已经保存了一个合法的整型变量地址s了，但问题是执行完成后，该函数就没有了，则s也没有了，最终就是p没有指向合法的变量s了。 //C)
#include <stdlib.h>
main()
{
int *p;
fun(&p); // 添加了取地址符，正确
...
}
int fun(int **q)
{
*q=(int*)malloc(); //构造一个int型数组, 请求系统分配4个字节的内存空间,此时*q即为p，则p指向了4个字节 } //执行完此行代码时，p已经指向了4个字节，且动态分配的内存没有释放，必须手动通过free释放 //D)
#include <stdlib.h>
main()
{
int *p;
fun(p);// 未添加取地址符，错误
...
} int fun(int *p)
{
p=(int *)malloc(sizeof(int));
}
故: 通过此题，可以了解到，我们可以跨函数使用内存
注意:
结构体变量不能加减乘除，但可以相互赋值
普通结构体变量和结构体指针变量作为函数传参的问题