C与指针。

1_指针理解

1.1变量的值

1.2变量的地址

1.3指针

1.4取变量的地址

2_分析指针

2.1分析指针变量的要素

2.2根据需求定义指针变量

3_指针的使用

3.1指针对变量的读操作

3.2指针对变量的写操作

4_指针占用空间的大小与位移

4.1指针占用空间的大小

4.2指针的位移

5_指针用于传递参数

5.1值传递与地址传递

6_函数与指针

6.1函数指针

6.2指针函数

6.3区分

7_数组与指针

7.1数组的地址

7.2数组元素的指针使用

7.3一道小题目练习一下

7.4传入数组到子函数

7.5字符串与指针

7.6数组指针的使用

8_结构体与指针

8.1结构体指针

9_链表

9.1空间分配的方式

9.2空间动态分配管理函数

9.3链表理解

9.4创建链表

9.5表尾添加节点

9.6表头添加节点

9.7表中添加节点

1_指针理解

1.1变量的值

根据需要的数据类型定义变量，内存会给定义的变量分配空间，就可以这个空间写入值了。

int a = 5; //5就是变量的值

1.2变量的地址

定义变量时，内存会分配对应的空间，且该空间会有地址编号，变量的地址编号值为分配的空间的首字节地址编号值。

1.3指针

指针是一种数据类型，用指针类型定义的变量称为指针类型变量（或称指针变量、指针）

指针变量是用来存储变量地址编号值的。

1.4取变量的地址

在C中可用 ’&‘来取变量的地址，格式如下：

&变量名

int a = 5; //5就是变量的值

int *p = &a; //定义一个指针变量p来存储a的地址

2_分析指针

2.1分析指针变量的要素

指针变量本质是一个变量，只不过这种变量存储的内容是变量的地址编号值。

分析指针变量的三要素：

变量名
指针的类型
指向的对象类型

（这些例子简单一眼就能看出来，但后面的数组指针，函数指针，结构体指针就不一定了，不过方法都是一样的）

int *p

变量名：p

指针类型：int * (除了变量名以外的内容都是）

指向对象类型：int （除了 *变量名以外的内容就是）

float *q

变量名：q

指针类型：float *

指向对象类型：float

int (*p)[20]

变量名：p

指针类型：int(*) [20]

指向对象类型：int [20]

int **p

变量名：p

指针类型：int **

指向对象类型：int *

2.2根据需求定义指针变量

格式：
指向对象类型 *变量名

先确定指针指向的变量的类型，然后再定义。

int a;      int *p;      p = &a;   //把a的地址存储到变量p中(指针变量p指向了变量a)

float b;    float *p;     p = &b;   //把b的地址存储到变量p中(指针变量p指向了变量b)

char c;    char *p;     p = &c;

int *m;    int **p;     p = &m;

指针变量p 存储了变量a的地址；== 也可以说指针变量p指向了变量a；

3_指针的使用

3.1指针对变量的读操作

#include<stdio.h>

int main()
{
    int *p;                     //定义一个可以储存int类型的指针变量p
    int a = 10;                 //定义一个整型变量a，并给a负值10
    p = &a;                     //将a的地址储存到变量p中（指针变量p指向了变量a)
    printf("p  :%d\n",p);       //p储存了a的地址值
    printf("&a :%d\n",&a);      //可以看到直接打印出a的地址值与打印指针变量p的值是一样的
    printf("*p :%d\n",*p);      //打印出指针变量p指向的变量a的值
    printf("a  :%d\n",a);       //可以看到打印指针变量p指向的变量a的值与直接打印出a的值相同

    return 0;
}

注意：

int *p; 在定义语句中，* 可以理解为指针变量的标志

printf("*p :%d\n",*p); 中的* 是取内容符号

3.2指针对变量的写操作

#include<stdio.h>

int main()
{
    int *p;                         //定义一个可以储存int类型的指针变量p
    int a = 10;                     //定义一个整型变量a，并给a负值10
    p = &a;                         //将a的地址储存到变量p中（指针变量p指向了变量a)
    printf("赋值前\na: %d\n*p: %d\n",a,*p); //未赋值前a和*p都为10
    *p = 20;                        //将20赋值给*p.也就是将20赋值给a
    printf("赋值后\na: %d\n*p: %d\n",a,*p); //可以看到a和*p都变成了20

    return 0;
}

4_指针占用空间的大小与位移

4.1指针占用空间的大小

关键字：sizeof

功能：计算对应类型的变量占用空间的大小（字节）

格式：sizeof(变量类型或变量名）

指针变量占用空间的大小与指向对象类型没有关系

#include<stdio.h>

int main()
{
    printf("%d\n",sizeof(int*));
    printf("%d\n",sizeof(int*[20]));  //(指针数组)相当与20个int*占用的空间大小
    printf("%d\n",sizeof(int(*)[20]));//(数组指针)

    return 0;
}

指针变量占用的空间大小：

指针变量占用空间4byte(32位平台)

指针变量占用空间8byte(64位平台)

4.2指针的位移

指针位移就是指针变量增减

指针变量的位移与指向对象类型有关

！！！此段代码仅供举例，在实际操作中最好不要将不同类型的指针变量相互赋值！！！

！！！在这里因为指针变量的大小都一样，所以强制赋值没有问题！！！

#include<stdio.h>

int main()
{
    int a = 0x12345678;          // 定义一个整数变量 a，并初始化为 0x12345678
    int *p;              // 定义一个 int 类型的指针 p
    char *q;             // 定义一个 char 类型的指针 q
    p = &a;              // 将指针 p 指向变量 a 的地址
    q = p;               // 将指针 q 指向指针 p 所指向的地址（即 a 的地址）

    printf("位移前\n");
    printf("p: %d   q: %d\n", p, q); // 输出指针 p 和 q 的值
    printf("*p: 0x%x   *q: 0x%x\n", *p, *q);
    p += 1;              // 将指针 p 向后移动 1 个 int 类型的大小
    q += 1;              // 将指针 q 向后移动 1 个 char 类型的大小

    printf("位移后\n");
    printf("p: %d   q: %d\n", p, q); // 输出指针 p 和 q 的位移后的值
    printf("*p: 0x%x   *q: 0x%x\n", *p, *q);
    return 0;
}

通过结果可以看出

p的地址编号偏移了4，q的地址编号偏移了1。看图：

总结：指针的移位跟指向对象的数据类型有关

int *p

指针跳动一步，指针变量里存储的地址编号就偏移4 地址编号+4

char *p

指针跳动一步，指针变量里存储的地址编号就偏移1 地址编号+1

short *p

指针跳动一步，指针变量里存储的地址编号就偏移2 地址编号+2

double *p

指针跳动一步，指针变量里存储的地址编号就偏移8 地址编号+8

补充：（指针位移的数组应用的很广泛，因为数组元素的地址是连续的，在其他变量的用处实际不大）

p+1; //p储存的地址不变（p = p + 1；//这样p储存的地址才会改变）

p++;//p储存的地址改变

5_指针用于传递参数

5.1值传递与地址传递

值传递是将实参的值传递给函数的参数，在调用函数时，会对实参的值拷贝一份副本，程序只会在函数内部对形参进行操作，不会对原始变量(实参)进行修改。

#include<stdio.h>

// 声明函数 mm，接受两个参数：一个 int 类型和一个 char 类型
void mm(int a, char c);

int main(void)
{
    int x = 10; 
    char y = 'A'; 

    mm(x, y); // 调用 mm 函数，传递 x 和 y 的值（值传递）

    // 打印 x 的值，由于值传递，x 的值在 mm 函数中没有变化，仍然是 10
    printf("x:%d\n", x); 

    // 打印 y 的值，由于值传递，y 的值在 mm 函数中没有变化，仍然是 'A'
    printf("y:%c\n", y);

    return 0;  // 返回 0，表示程序正常结束
}

// 定义 mm 函数，接受两个参数：一个 int 类型的 a 和一个 char 类型的 c
void mm(int a, char c)
{
    // 在函数内部，a 被修改为原来 a 的值加 1，即 10 + 1 = 11
    a = a + 1;  
    
    // 在函数内部，c 被修改为原来 c 的值加 1，即 'A' 的 ASCII 值为 65，加 1 后变为 66，对应字符 'B'
    c = c + 1;

    // 打印修改后的 a 和 c 的值
    printf("a:%d\n", a);  // 输出 11，因为 a 被修改为 11
    printf("c:%c\n", c);  // 输出 'B'，因为 c 被修改为 'B'
}

地址传递是将实参的地址（指针）传递给参数。在这种方式，函数的参数实际上指向了实参的地址，在调用函数时，会对原始变量（实参）进行操作。

#include<stdio.h>
void mm(int *a, char *c);

int main(void)
{
    int x = 10;
    char y = 'A';

    mm(&x, &y);  // 传递变量的地址

    printf("x: %d\n", x);  // 这里的 x 会被修改为 11
    printf("y: %c\n", y);  // 这里的 y 会被修改为 'B'

    return 0;
}

void mm(int *a, char *c)
{
    *a = *a + 1;  // 修改 a 指针指向的值
    *c = *c + 1;  // 修改 c 指针指向的值
    printf("a: %d\n", *a);  // 11
    printf("c: %c\n", *c);  // 'B'
}

地址传递使用场景：

想要在函数中改变实参的值。

想要获取子函数中的数据(特别是想要多个数据的时候)。ex:

子函数中寻找100~999中的所有水仙花数打印

主函数要水仙花数的个数和总和

/*********************************************************************
水仙花数（Narcissistic Number） 是指一个 n 位数，其每个数字的 n 次方和
等于它本身。
例如，三位数的水仙花数是指，某个三位数的每个数字的立方和等于这个数本身。
**********************************************************************/
#include<stdio.h>
int sxh(int *s, int *c);

int main(void)
{
    int sum = 0,cont = 0;
    sxh(&sum,&cont);

    printf("水仙花数的和为：%d\n",sum);
    printf("水仙花数的个数：%d\n",cont);

    return 0;
}

int sxh(int *s, int *c)
{
    int i,ge,shi,bai;
    printf("水仙花数有:\n");
    for(i = 100;i <= 999;i++)
    {
        ge  = (i / 1)   % 10;
        shi = (i / 10)  % 10;
        bai = (i / 100) % 10;
        if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i)
        {
            printf("%d\n",i);
            *s += i;
            (*c)++;
        }

    }
    return 0;
}

需要传递一个数组到子函数中。（看数组与指针部分）

6_函数与指针

6.1函数指针

指向对象类型是函数的指针叫函数指针，本质是指针。

作用：储存函数的地址变化值（函数的地址编号可以用函数名表示）

int (*f)(char a);

中间(*f)的括号必须加，不加就变成了指针函数，指针函数本质是函数。（后面会区分）

变量名：f

指针类型：int (*) (char a) (除了变量名以外的内容都是）

指向对象类型：int (char a) （除了 *变量名以外的内容就是）

作用：存一个函数的地址，该函数的返回值为int类型且有一个char类型参数。

#include<stdio.h>

int mm(char a);
int main(void)
{
    printf("int(*)(char a)类型的指针占用空间的大小为%dbyte\n",sizeof(int(*)(char a)));
    int(*f)(char a);  //定义一个函数指针
    f = mm;           //将函数的地址赋值给指针变量f

    //通过函数名调用函数
    int a = mm('A');
    printf("'A'的ASCII值为：%d\n",a);

    //当通过函数指针调用
    int b = f('B');
    printf("'B'的ASCII值为：%d\n",b);

    //通过解引用函数指针调用
    int c = （*f）('C');
    printf("'C'的ASCII值为：%d\n",c);

    return 0;
}

int mm(char a)
{
    printf("进入int (char a)类型的函数\n");
    printf("函数的功能为打印字符%c并返回其ASCII值\n",a);
    return a;
}

多举2个例子：

int (*p)(void);

变量名：p

指针类型：int (*) (void) (除了变量名以外的内容都是）

指向对象类型：int (void) （除了 *变量名以外的内容就是）

作用：存一个函数的地址，该函数的返回值为int类型且没有参数。

void (*q)(int a,char *b);

变量名：q

指针类型：void (*) (int a,char *b) (除了变量名以外的内容都是）

指向对象类型：void (int a,char *b) （除了 *变量名以外的内容就是）

作用：存一个函数的地址，该函数无返回值为且有一个int类型和char *类型参数。

函数指针的使用场景：
将一个函数作为另一个函数的参数。

ex:通过接口函数启动功能函数。

#include<stdio.h>

void fun(void(*q)(void)); // 声明接口函数
void f1(void); // 声明功能函数1
void f2(void); // 声明功能函数2
void f3(void); // 声明功能函数3
void f4(void); // 声明功能函数4
void f5(void); // 声明功能函数5

int main(void)
{
    fun(f1); // 通过接口函数调用功能函数
    fun(f2);
    fun(f3);
    fun(f4);
    fun(f5);

    return 0;
}

// 接口函数：接收一个函数指针并调用对应的功能函数
void fun(void(*q)(void))
{
    (*q)(); // 调用传入的函数
}

// 功能函数1
void f1(void)
{
    printf("进入功能块1\n");
}

// 功能函数2
void f2(void)
{
    printf("进入功能块2\n");
}

// 功能函数3
void f3(void)
{
    printf("进入功能块3\n");
}

// 功能函数4
void f4(void)
{
    printf("进入功能块4\n");
}

// 功能函数5
void f5(void)
{
    printf("进入功能块5\n");
}

更多接口函数例子==》C语言_接口函数

6.2指针函数

指针函数本质是一个函数，一个可以返回地址编号的函数。

int *f(void);

函数名： f

参数：无

返回值：int *

作用 : 该函数的返回值是地址编号，需要定义一个指针变量接收。

指针函数的使用场景：

用于动态分配。

int *malloc(int n);

具体看后面的链表章节

6.3区分

有括号的就是函数指针，没有括号的就是指针函数（类似数组指针和指针数组）。

分析

int (*mm)(void (*f)(float b), int a, char *m);

int *mm(void (*f)(float b), int a, char *m);

int *(*mm)(void (*f)(float b), int a, char *m);

int (*mm)(void (*f)(float b), int a, char *m);

函数指针：

变量名：mm

指针类型：int (*)(void(*f)(float b),int a,char *m)

指向对象类型：int (void(*f)(float b),int a,char *m)

这是一个指针变量，指针存储函数的地址，函数的要求如下：

返回值类型： int
参数： int a //传入一个整型值

char * m //传入一个字符型变量的地址

void(*f)(float b) //传入一个函数的地址，函数要求如下：

返回值：无

参数： float b //传入一个浮点值

#include <stdio.h>

// 定义一个简单的函数，接受一个 float 类型的参数
void example_function(float b) {
    printf("接收到的 float 值: %f\n", b);
}

// 定义一个函数，符合 mm 的签名，接收一个函数指针、一个整数和一个字符串
int my_function(void (*f)(float b), int a, char *m) {
    printf("整数: %d, 字符串: %s\n", a, m);
    f(3.14);  // 调用传入的函数 f
    return a * 2;
}

int main() {
    // 定义函数指针 mm，指向 my_function
    int (*mm)(void (*f)(float b), int a, char *m) = my_function;

    // 通过 mm 调用 my_function，并传入 example_function、整数 5 和字符串 "Hello, World!"
    int result = mm(example_function, 5, "Hello, World!");

    printf("结果: %d\n", result);
    return 0;
}

int *mm(void (*f)(float b), int a, char *m);

指针函数：

函数名： mm

返回值： int *

参数： int a //传入一个整型值

char * m //传入一个字符型变量的地址

void(*f)(float b) //传入一个函数的地址，函数要求如下：

返回值：无

参数： float b //传入一个浮点值

#include <stdio.h>
#include <stdlib.h>

// 这是一个符合要求的函数，接收一个 float 类型的参数，并返回 void
void example_function(float b) {
    printf("函数 example_function 被调用，参数为: %f\n", b);
}

// mm 函数，返回一个 int* 指针
int* mm(void (*f)(float b), int a, char *m) {
    // 打印传入的整数和字符串
    printf("传入的整数 a: %d\n", a);
    printf("传入的字符串 m: %s\n", m);

    // 调用传入的函数 f，传入一个 float 参数
    f(3.14);

    // 使用 malloc 分配内存
    int *result = (int*)malloc(sizeof(int));
    if (result != NULL) {
        *result = a * 2;  // 计算并存储结果
    }
    return result;  // 返回指向结果的指针
}

int main() {
    // 定义一个函数指针 f，指向 example_function
    void (*f_ptr)(float) = example_function;

    // 调用 mm 函数，传入函数指针 f_ptr，整数 5 和字符串 "Hello"
    int *result = mm(f_ptr, 5, "Hello");

    // 打印 mm 函数返回的 int* 指针值和指针解引用后的值
    if (result != NULL) {
        printf("计算结果的指针地址: %p\n", (void*)result);
        printf("解引用后的结果: %d\n", *result);

        // 使用完 malloc 分配的内存后，记得释放它
        free(result);
    }

    return 0;
}

int *(*mm)(void (*f)(float b), int a, char *m);

函数指针：

变量名：mm

指针类型：int *(*)(void(*f)(float b),int a,char *m)

指向对象类型：int * (void(*f)(float b),int a,char *m)

这是一个指针变量，指针存储函数的地址，函数的要求如下：

返回值类型： int *
参数： int a //传入一个整型值

char * m //传入一个字符型变量的地址

void(*f)(float b) //传入一个函数的地址，函数要求如下：

返回值：无

参数： float b //传入一个浮点值

#include <stdio.h>
#include <stdlib.h>

// 这是一个符合要求的函数，接收一个 float 类型的参数，并返回 void
void example_function(float b) {
    printf("函数 example_function 被调用，参数为: %f\n", b);
}

// mm 函数的实现，符合声明
int *mm(void (*f)(float b), int a, char *m) {
    // 打印传入的整数和字符串
    printf("传入的整数 a: %d\n", a);
    printf("传入的字符串 m: %s\n", m);

    // 调用传入的函数 f，传入一个 float 参数
    f(3.14);

    // 计算 a * 2，并返回其地址
    int *result = (int *)malloc(sizeof(int));  // 动态分配内存
    if (result != NULL) {
        *result = a * 2;
    }
    return result;
}

int main() {
    // 定义一个函数指针 f，指向 example_function
    void (*f_ptr)(float) = example_function;

    // 定义一个函数指针 mm，指向 mm 函数
    int *(*mm_ptr)(void (*f)(float b), int a, char *m) = mm;

    // 调用 mm 函数，传入函数指针 f_ptr，整数 5 和字符串 "Hello"
    int *result = mm_ptr(f_ptr, 5, "Hello");

    // 打印 mm 函数返回的 int* 指针值和指针解引用后的值
    if (result != NULL) {
        printf("计算结果的指针地址: %p\n", (void*)result);
        printf("解引用后的结果: %d\n", *result);

        // 使用完 malloc 分配的内存后，记得释放它
        free(result);
    }

    return 0;
}

7_数组与指针

7.1数组的地址

！！！数组的首元素地址属性和数组的地址属性不一样！！！

数组的首元素地址：
0号元素的地址属性表示首个元素的地址

数组名代表数组首元素地址（或 &a[0]）

偏移：a+1;偏移一个数组元素的长度地址

数组的地址：

数组的地址的属性表示整个数组的地址：&a

数组的首元素地址编号值和数组的地址编号值一样，但偏移量不一样

偏移：&a+1;偏移一个数组的长度地址，即偏移量 == 元素个数 * 元素类型大小

7.2数组元素的指针使用

由于数组名可以代码数组首元素地址，所以通过：

（数组名+i）的形式表示数组的i号元素的地址

*（数组名+i）的形式来获取数组的i号元素的值

注意：

数组名只能代表数组首元素的地址，不能代表其他元素的地址

所以用数组名访问的时候，不能用数组名++ 的形式

也可以通过指针变量来访问数组的元素：

通过指针操作数组中的元素,要先定义一个可以指向数组元素的指针,

然后，

通过p++的形式访问某个元素的地址 //指针变量p存储的地址是变化的

通过*p的形式访问某个元素的内容 //要注意指针某一时刻存了谁的地址

也可以

通过p+i的形式访问某个元素的地址 //指针变量p存的地址不变,一直是首元素地址

通过*(p+i)的形式访问某个元素的内容

7.3一道小题目练习一下

如果定义：

char a,b,c,d,e,f,x,y;
char niu[6];
niu[0] = 3;
niu[1] = 6;
niu[2] = 10;
niu[3] = 21;
niu[4] = 40;
niu[5] = 50;
char *sp = niu;

求：

a=*sp;

b=*sp+1;

c=*sp++;

d=*sp;

e=*(sp+1);

f=*sp;

x = sizeof(niu[6]);
y = sizeof(niu);
z = sizeof(char[6]);
k = sizeof(sp);

的结果（注意假设程序从上往下执行）：

a= b= c= d=

e= f= x= y=

z= k=

#include<stdio.h>


int main(void)
{
    char a,b,c,d,e,f,x,y,z,k;
    char niu[6];
    niu[0] = 3;
    niu[1] = 6;
    niu[2] = 10;
    niu[3] = 21;
    niu[4] = 40;
    niu[5] = 50;
    char *sp = niu;

    a = *sp;            //sp指向niu[0]    a = niu[0] = 3
    b = *sp+1;          //sp指向niu[0]    b = niu[0]+1 = 4
    c = *sp++;          //sp指向niu[0]    c = niu[0] = 3  (*sp++ == *(sp++)    sp++运算符是先赋值后自增，所以本次赋值在自增前）
    d = *sp;            //sp指向niu[1]    d = niu[1] = 6  (上一行代码进行了自增）
    e = *(sp+1);        //sp指向niu[1],但（sp+1)的地址为niu[2]  e = niu[2] = 10
    f = *sp;            //sp指向niu[1]    f = niu[1] = 6
    x = sizeof(niu[6]);
    y = sizeof(niu);
    z = sizeof(char[6]);
    k = sizeof(sp);

    printf("a = %d\n",a);
    printf("b = %d\n",b);
    printf("c = %d\n",c);
    printf("d = %d\n",d);
    printf("e = %d\n",e);
    printf("f = %d\n",f);
    printf("x = %d\n",x);
    printf("y = %d\n",y);
    printf("z = %d\n",z);
    printf("k = %d\n",k);

    return 0;
}

思考：如果把代码中所以char改为int,指针的偏移有什么变换？（看4.2指针的位移）

7.4传入数组到子函数

数组的空间特点：元素空间分配连续

基于数组的空间特点，我们可以吧数组的首元素地址传给子函数（子函数定义一个指针变量的形参来接收数组首元素地址），子函数就可以通过地址偏移的方式访问所以数组元素。

1. 用户在主函数中定义一个数组,往数组中输入10个数据

写一个子函数，统计用户输入的数据非负数的个数打印

并且求非负数的和返回给主函数在主函数中打印。

#include <stdio.h>

int Sub(int *p, int n);

int main()
{
    int a[10];  // 存储用户输入的 10 个数
    int value;  // 存储非负数的和

    printf("请输入10个数:\n");
    // 输入 10 个整数
    for (int i = 0; i < 10; i++)
    {
        scanf("%d", &a[i]);
    }

    // 计算并返回非负数的和
    value = Sub(a, 10);

    // 输出非负数的和
    printf("非负数的和为：%d", value);

    return 0;
}

// 计算非负数的和
int Sub(int *p, int n)
{
    int sum = 0;  // 初始化和为 0

    // 输出非负数
    printf("非负数有：\n");
    // 遍历数组中的所有元素
    for (int i = 0; i < n; i++)  // 使用传入的数组大小 n
    {
        if (*(p + i) >= 0)  // 判断当前元素是否为非负数
        {
            printf("%d\n", *(p + i));  // 打印当前的非负数
            sum += *(p + i);  // 将非负数累加到 sum
        }
    }

    return sum;  // 返回非负数的和
}

2. 用户在主函数中输入数组后

在子函数中去掉最大最小求平均值

返回平均值在主函数中打印

插个知识点：

冒泡排序

作用：将数组中的数据进行从大到小或者从小到大排序

原理：

int a[6] = { 68 , 100 , 90 , 34 , 200 , 60};

说明：轮数循环从1开始，每轮比较的次数 j == 数据个数 n - 轮数 i

每轮比较的次数从0开始，因为要用这个循环变量当数组的下标。

#include <stdio.h>


float Average(int *p, int n);

int main()
{
    int a[10];  
    float average;  
    printf("请输入10个数:\n");
    
    for (int i = 0; i < 10; i++)
    {
        scanf("%d", &a[i]);  /
    }

    average = Average(a, 10);
    printf("去掉最大最小后的平均值为%.2f\n", average);
    return 0;  
}

// 计算去掉最大最小数后的平均值的函数定义
float Average(int *p, int n)
{
    int temp, sum = 0;  // 临时变量 temp 用于交换，sum 初始化为 0，用来累加去掉最大最小数后的和
    float aver;  // 存储计算出的平均值
    
    // 冒泡排序，按升序排列数组
    for (int i = 1; i < n; i++)  // 外层循环：每次将最大的数移动到末尾
    {
        for (int j = 0; j < n - i; j++)  // 内层循环：比较相邻的两个数，较大的数交换到后面
        {
            if (p[j] > p[j + 1])  // 如果当前数比下一个数大，则交换
            {
                temp = p[j];  // 保存当前数
                p[j] = p[j + 1];  // 将下一个数赋值给当前数
                p[j + 1] = temp;  // 将保存的当前数赋值给下一个数
            }
        }
    }

    // 去掉最大值和最小值后，计算剩余部分的和
    for (int k = 1; k < n - 1; k++)  // 从第二个元素开始，到倒数第二个元素
    {
        sum += p[k];  // 累加每个元素到 sum
    }

    // 计算去掉最大最小数后的平均值
    aver = (float)sum / (n - 2);  // 计算平均值，确保进行浮点数运算

    return aver;  // 返回计算出的平均值
}

在上面2段代码中，关于在子函数调用数组我用了2中不同的形式：

用指针的形式：*（p+i）

用数组的形式：p[i]

虽然形式参数的类型是指针，但这两种方式是等价的，*(p + i) 等价于 p[i]，

想想在用数组的时候是不是也用过指针的形式调用数组。

7.5字符串与指针

字符串其实是数组，用指针操作字符串其实就是用指针操作数组，在这不讲太多，可以看下这C_字符串其实就是字符数组

也可以看看下一节关于数组指针操作字符的二维数组的部分。

7.6数组指针的使用

区分：

数组指针： char (*p)[10]; 这是一个指针，可以存一个char [10]类型的数组的地址编号

指针数组： int *p[10]; 这是一个数组，可以存10个int * 类型的指针变量

有括号为指针，无括号为数组（跟函数指针和指针函数类似）

数组指针存了数组的地址编号，意味着整体操作数组，这多很多类型的数组没有操作价值，但可以操作字符数组，也就是操作字符串，一般用在字符的二维数组。

接下来讲讲数组指针操作字符的二维数组：

①定义一个数组指针

char (*p)[10];

变量名：p

指针类型：char *[10]

指向对象类型：char [10]

②明确指向

假如有一个字符的二维数组：

char a[10][10];

p = a;

③使用

p++; //指针指向改变

p+1; //指针指向不变

练习：

主函数有一个指令包,指令包里有10个字符串指令，

用户再输入一个字符串指令,

写一个子函数,判断用户输入的字符串指令是否在指令包中,

如果在指令包中返回1,不在指令包中返回0。

分析:

10个指令存在一个二维数组中

主函数:

指令包二维数组

用户输入指令字符串

子函数:

参数:char (*p)[10], char *m

返回值: int

说明:

和二维数组中的每个字符串进行对比,对比成功返回1,失败返回0

#include <stdio.h>
#include <string.h>

int Judge(char (*p)[10],char *i);

int main()
{
    int judge;
    char package[10][10] = {"123456","abcd","98765",
                            "55555","4444","333","22",
                            "liao","jia","tong"};
    char ins[10];
    printf("请输入指令：");
    scanf("%s",ins);

    judge = Judge(package,ins);
    if(judge == 1)
    {
        printf("输入正确\n");
    }
    else if(judge == 0)
    {
        printf("输入错误\n");
    }

    return 0;
}



/*******************************************************
函数名     : Judge
函数功能   : 判断指令是否在指令包中
函数参数   : char (*p)[10], char *i
函数返回值 : int
函数描述   : 如果字符串i在字符串数组p中，则返回1，不在则返回0
*******************************************************/


int Judge(char (*p)[10], char *i)
{
    for (int j = 0; j < 10; j++) {
        if (strcmp(p[j], i) == 0) {  // 如果匹配
            return 1;  // 返回 1 表示输入正确
        }
    }
    return 0;  // 如果没有匹配，返回 0
}



//int Judge(char (*p)[10],char *i)
//{
//    int j = 0;
//    while(*(p+j) != NULL)
//    {
//        if(strcmp((char *)(p+j),i)) == 0)
//        {
//            return 1;
//        }
//        j++;
//    }
//    return 0;
//}

8_结构体与指针

关于结构体的基础知识在这里不讲，有需要可以看这==》C_结构体

8.1结构体指针

假如已经声明了一个结构体：

typedef struct book
{
char title[50]; // 书名
char author[50]; // 作者
char id[50]; // 书籍编号
float pop; // 热度
int stock; // 库存
float price; // 价格
} BOK; // 结构体类型的别名 BOK

定义一个结构体指针：

BOK *f;

变量名：f

指针类型：BOK *

指向对象类型：BOK

使用：

明确指向：

BOK bk1;

f = bk1;

格式：

这个符号： -> 是结构体指针特有的，是结构体元素到结构体具体成员的指向。

结构体指针变量名->成员变量名;

f->title f->price

#include <stdio.h>
#include <string.h>
typedef struct book
{
    char title[50];     // 书名
    char author[50];    // 作者
    char id[50];        // 书籍编号
    float pop;          // 热度
    int stock;          // 库存
    float price;        // 价格
} BOK;  // 结构体类型的别名 BOK

int main()
{
    BOK bk1 =
    {
        "C Programming",    // title
        "Dennis Ritchie",   // author
        "001",              // id
        4.5,                // pop
        10,                 // stock
        39.99               // price
    };
    
    BOK *f;
    f = &bk1;
    f -> price = 29.99;
    strcpy(f -> title , "C语言");
    
    printf("Book 1: %s by %s\n ID: %s\n Popularity: %.2f\n Stock: %d\n Price: %.2f\n",
           f->title, f->author, f->id, f->pop, f->stock, f->price);
    return 0;
}

9_链表

9.1空间分配的方式

自动分配：

系统根据用户定义的变量来分配空间，分配的位置为栈区。

访问可以通过变量访问，也可以通过地址访问。

动态分配：

用户通过动态分配函数人为申请空间，人为释放空间申请到的空间在堆区。

分配到的空间没有名字，只能通过地址访问。

9.2空间动态分配管理函数

malloc函数：

函数原型：

#include <stdlib.h> //头文件

void *malloc(unsigned int size); //函数

函数名： malloc

函数参数：unsigned int size

函数返回值：void *

说明：此函数有1个整型参数size,这个参数是用来请求分配的内存块大小的，

单位是字节（byte），此函数会返回一个地址编号，所在地址中存的数据类型不确定。

功能 : 在堆区申请一块size字节的空间

会把申请到的空间的地址的首字节编号返回，如果分配失败则返回NULL

此空间没有类型（可以强转成任何地址类型）

注意：申请空间是为了存数据

申请到的空间要类型转换

返回的是申请到的空间的首字节地址

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 请求分配一个整数大小的内存
    int* ptr = (int*)malloc(sizeof(int));

    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 使用分配的内存
    *ptr = 10;
    printf("存储的值是: %d\n", *ptr);

    // 释放分配的内存
    free(ptr);

    return 0;
}

free函数：

函数原型：

#include <stdlib.h> //头文件

void free(void *prt); //函数

函数名：free

函数参数：void *prt

函数返回值：无

功能 : 释放指针指向的堆区空间的内容

权限自由

注意：释放的是空间里的内容，不是空间

调用后，*prt的值发生了变化，因为这块空间里的内容已经释放掉了，但prt还是

指向这块空间的首地址，不太好，所以最好：

prt = NULL; //避免”野指针“

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 动态分配内存
    int* ptr = (int*)malloc(sizeof(int));

    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 使用分配的内存
    *ptr = 42;
    printf("存储的值是: %d\n", *ptr);

    // 释放分配的内存
    free(ptr);
    
    // 注意：释放后，不要再使用该指针
    ptr = NULL;  // 设为NULL，避免悬空指针问题

    return 0;
}

calloc函数：

#include <stdlib.h> //头文件

void *calloc(unsigned int num,unsigned int size); //函数

函数名： calloc

函数参数：unsigned int num,unsigned int size

函数返回值：void *

说明：此函数有2个整型参数 num和size,num是要申请的内存块数，size是用来请求分配的每块内存块大小的，单位是字节（byte）。

功能 : 在堆区申请num块size字节的空间

会把申请到的空间的地址的首字节编号返回，如果分配失败则返回NULL

此空间没有类型（可以强转成任何地址类型）

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 分配并初始化 10 个整数大小的内存块
    int* ptr = (int*)calloc(10, sizeof(int));

    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 打印每个元素的值（应为 0，因为 calloc 初始化了内存）
    for (int i = 0; i < 10; i++) {
        printf("ptr[%d] = %d\n", i, ptr[i]);
    }

    // 释放分配的内存
    free(ptr);

    return 0;
}

calloc和malloc的区别主要是以下两点：