C语言：函数指针，数组，结构体

函数指针、数组、结构体

一、函数指针

1.1 函数名

• 一个函数在编译时被分配一个入口地址，这个地址就称为函数的指针，函数名代表函数的入口地址

#include 

// 一个函数在编译时被分配一个入口地址，这个地址就称为函数的指针，函数名代表函数的入口地址
void func() {
    printf("这是func函数内部的打印n");
}

int main() {
    // 函数名，编译器做了特殊处理，func, &func, *func 都是指同一个地址
    printf("%p, %p, %pn", func, &func, *func);
    // 调函数     函数地址()
    func();
    (&func)();
    (*func)();

    return 0;
}

1.2 函数指针

• 函数指针：它是指针，指向函数的指针

• 语法格式：

  返回值 (*函数指针变量)(形参列表);
  

  • 函数指针变量的定义，其中返回值、形参列表需要和指向的函数匹配

#include 

/*
// ============= 无参无返回值
void f1() {}

// p1 函数指针变量
void (* p1)(); // 先定义变量
p1 = f1;  // 再赋值
// 定义同时初始化
void (* p11)() = f1;

// ============= 有参无返回值
void f2(int a, int b, int c) {}
void (* p2)(int, int, int) = f2;

// ============= 有参有返回值
int f3(int a, int b) { return 1;}
int (* p3)(int, int) = f3;
*/

// 函数定义
int my_add(int a, int b) {
    int res = a + b;

    return res;
}

int main() {
    // 定义一个变量 p1, 指向my_add
    int (* p1)(int, int) = my_add; // 定义同时赋值，叫初始化
    int temp = p1(1, 2); // 简单理解  p1就是my_add的别名
    printf("temp = %dn", temp);

    int (* p2)(int, int); // 先定义
    p2 = my_add; // 后赋值
    temp = p2(10, 10);
    printf("temp = %dn", temp);

    return 0;
}

1.3 回调函数

• 函数指针变量做函数参数，这个函数指针变量指向的函数就是回调函数
• 回调函数可以增加函数的通用性：在不改变原函数的前提下，增加新功能

#include 

// 函数定义
int my_add(int a, int b) { // 具体实现功能
    return a + b;
}

int my_sub(int a, int b) { // 具体实现功能
    return a - b;
}

// 有个想法  计算器  知道有2个参数   具体实现没有想好
// p 函数指针变量
// 回调函数可以增加函数的通用性：在不改变原函数的前提下，增加新功能
int calc(int x, int y, int (*p)(int, int)) { // 计算器，这个函数是框架，不实现功能，也不关心具体实现，留好通过的位置
    int temp = p(x, y); // 调用别的函数实现功能，p就是回调函数
    return temp;
}

int main() {
    int temp;
    temp = calc(1, 2, my_add);
    printf("加法：temp = %dn", temp);

    temp = calc(1, 2, my_sub);
    printf("减法：temp = %dn", temp);

    return 0;
}

二、数组

2.1 基本语法

2.1.1 数组的使用

• 数据类型：数组中所有元素的类型（int、float、char等）
• 数组名：标识符，遵循变量命名规则
• 元素个数：编译时确定的正整数（常量表达式）

#include 

int main() {
    // 定义同时赋值，叫初始化
    int arr[5] = {1, 2, 4, 5, 6};
    //            0  1  2  3  4
    arr[0] = 8; // 修改元素
    // 不要使用下标不存在的元素，越界，超过数据范围，后面容易导致程序崩溃
    // arr[10] = 99; // err
    printf("%d, %d, %d, %d, %dn", arr[0], arr[1], arr[2], arr[3], arr[4]);
    // for 遍历  
    for(int i = 0; i 5; i++) { // i = 0, 1, 2, 3, 4
        printf("%d, ", arr[i]);
    }

    return 0;
}

2.1.2 数组的初始化

• 在定义数组的同时进行赋值，称为初始化
• 全局数组若不初始化，编译器将其初始化为零
• 局部数组若不初始化，内容为随机值

#include 

int main() {
    // 全部初始化
    int a1[5] = {1, 2, 3, 4, 5};
    // 部分初始化，没有初始化的，默认赋值为0
    int a2[5] = {1, 2};
    // 所有元素初始化为0
    int a3[5] = {0};
    // 定义的时候， []可以不写数字，一定要初始化
    int a4[] = {1, 3, 5, 7, 9}; // 根据初始化的元素个数确定数组的大小

    // for 遍历  
    for(int i = 0; i 5; i++) { // i = 0, 1, 2, 3, 4
        printf("%d, ", a4[i]);
    }

    return 0;
}

2.1.3 数组名

• 数组名是一个地址的常量，代表数组中首元素的地址

#include 

int main() {
    int a[] = {1, 3, 5, 7, 9}; // 内容，元素
    //         0  1  2  3  4   位置，下标
    // 数组名是一个地址的常量
    // a = NULL; // err
    // 代表数组中首元素的地址
    printf("a = %p, &a[0] = %pn", a, &a[0]);
    // sizeof(a) 和 sizeof(&a[0]) 区别
    // 编译器对数组名做特殊处理，sizeof(a) 不是测量指针的大小，测量这个数组的大小
    // 有5个元素，每个元素是int类型   5 * sizeof(int) = 5 * 4 = 20
    printf("sizeof(a) = %d, sizeof(&a[0]) = %dn", sizeof(a), sizeof(&a[0]));
    // 求 元素个数    总大小 / 一个元素的大小
    printf("%d, %dn", sizeof(a)/sizeof(int), sizeof(a)/sizeof(a[0]));

    return 0;
}

2.2 数组案例

2.2.1 一维数组的最大值

#include 
#include  // srand()   rand()
#include    // time()

int main() {
    int a[10];
    int n = sizeof(a)/sizeof(a[0]);
    srand(time(0)); // 随机种子

    // 分别赋值，50以内的随机数  1~50
    for (int i = 0; i 50 + 1;
        printf("%d, ", a[i]);
    }
    printf("n");

    int max = a[0]; // 假设第0个元素为最大值
    for (int i = 1; i if (max // 保存最大值
        }
    }

    printf("max = %dn", max);

    return 0;
}

int main01() {
    // int a[10];
    // 分别赋值，50以内的随机数  1~50

    // 1. 随机种子
    srand(time(0));
    // 2. 产生随机数
    int n = rand();
    printf("n = %dn", n);

    int m = rand() % 50 + 1;
    printf("m = %dn", m);

    return 0;
}

2.2.2 一维数组的逆置

#include 
#include  // srand()   rand()
#include    // time()

int main() {
    int a[10];
    int n = sizeof(a)/sizeof(a[0]);
    srand(time(0)); // 随机种子

    // 分别赋值，50以内的随机数  1~50
    for (int i = 0; i 50 + 1;
        printf("%d, ", a[i]);
    }
    printf("n");
    int left = 0;
    int right = n - 1;
    int temp;

    while(left for (int i = 0; i printf("%d, ", a[i]);
    }
    printf("n");

    return 0;
}

2.3 数组和指针

2.3.1 通过指针操作数组元素

• 数组名字是数组的首元素地址，但它是一个常量
• * 和 [] 效果一样，都是操作指针所指向的内存

#include 

int main() {
    int a[5] = {1, 3, 5, 7, 9};
    // 定义一个变量，保存首元素地址，首元素是int,  需要int *
    int * p;
    p = &a[0]; // p不是指向整个数组，只是指向首元素
    p = a; // a和&a[0]一样

    // *(p+i) ===> p[i]   * 和 [] 效果一样，都是操作指针所指向的内存
    for (int i = 0; i 5; i++) {
        printf("%d, %dn", *(p+i), p[i]);
    }

    return 0;
}

int main01() {
    int a = 10;

    int * p = &a;

    // * 和 [] 效果一样，都是操作指针所指向的内存
    // *p = 123;
    // *(p+0) = 123;  // ====>   *(p+i) ===> p[i]
    p[0] = 123;

    printf("%d, %d, %d, %dn", a, *p, *(p+0), p[0]);

    return 0;
}

2.3.2 指针数组

• 指针数组，它是数组，数组的每个元素都是指针类型

#include 

int main() {
    // 指针数组，它是数组，数组的每个元素都是指针类型
    int a = 10, b = 20, c = 30;

    int * p[] = {&a, &b, &c};

    for (int i = 0; i 3; i++) {
        printf("%d, %d, %dn", *(p[i]), *(p[i]+0), p[i][0]);
    }

    return 0;
}

int main01() {
    int a = 10, b = 20, c = 30;
    int * p1 = &a;
    int * p2 = &b;
    int * p3 = &c;

    return 0;
}

2.3.3 数组名做函数参数

• 数组名做函数参数，函数的形参本质上就是指针

#include 

// 数组名做函数参数，函数的形参本质上就是指针
void print_arr2(int a[5]) { // 形参数组，不是数组，是指针变量
    // a = NULL; // 是变量才能赋值
    // printf("形参的数组 sizeof(a) = %dn", sizeof(a)); // 8, 64位系统，指针大小为8
}

// void print_arr(int a[5], int n)
// void print_arr(int a[], int n)
void print_arr(int * a, int n)  // 9、10、11行，等价，只有指针变量，保存首元素地址
{
    for (int i = 0; i printf("%d, ", a[i]);
    }
    printf("n");
}

int main() {
    int a[5] = {1, 3, 5, 7, 9};
    // 非形参的数组，是数组
    // a = NULL; // 数组名是常量
    printf("非形参的数组 sizeof(a) = %dn", sizeof(a)); // 20, 整个数组大小

    print_arr(a, 5);
    // print_arr(&a[0], 5); // a和&a[0]值一样

    return 0;
}

2.3.4 二维数组

二维数组在内存中的存储方式是按行连续存储的，即先依次存储第0行的所有元素，接着再存储第1行，以此类推。 以int a[2][3]为例，它在内存中的布局情况如下：

• a[0][0] → a[0][1] → a[0][2] → a[1][0] → a[1][1] → a[1][2]

#include 

int main() {
    // 3个 int [4]  3个一维数据
    int a[3][4] = {
        {00, 01, 02, 03},
        {10, 11, 12, 13},
        {20, 21, 22, 23},
    };

    for (int i = 0; i 3; i++) { // i = 0, 1, 2
        for (int j = 0; j 4; j++) { // j = 0, 1, 2, 3
            // 打印保留2位，不够，前面补0
            printf("%02d, ", a[i][j]);
        }
        printf("n");
    }

    return 0;
}

2.4 字符数组与字符串

2.4.1 字符数组与字符串区别

• C语言中没有字符串这种数据类型，可以通过char的数组来替代
• 数字0(和字符 '