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

哈哈哼嘿2025-08-22 10:00

函数指针、数组、结构体

一、函数指针

1.1 函数名

  • 一个函数在编译时被分配一个入口地址，这个地址就称为函数的指针，函数名代表函数的入口地址
c 复制代码 
#include <stdio.h>

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

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

    return 0;
}

1.2 函数指针

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

  • 语法格式：

    c 复制代码 
    返回值 (*函数指针变量)(形参列表);
    • 函数指针变量的定义，其中返回值、形参列表需要和指向的函数匹配
c 复制代码 
#include <stdio.h>

/*
// ============= 无参无返回值
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 = %d\n", temp);

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

    return 0;
}

1.3 回调函数

  • 函数指针变量做函数参数，这个函数指针变量指向的函数就是回调函数
  • 回调函数可以增加函数的通用性：在不改变原函数的前提下，增加新功能
c 复制代码 
#include <stdio.h>

// 函数定义
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 = %d\n", temp);

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

    return 0;
}

二、数组

2.1 基本语法

2.1.1 数组的使用
  • 数据类型：数组中所有元素的类型（int、float、char等）
  • 数组名：标识符，遵循变量命名规则
  • 元素个数：编译时确定的正整数（常量表达式）
c 复制代码 
#include <stdio.h>

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, %d\n", 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 数组的初始化
  • 在定义数组的同时进行赋值，称为初始化
  • 全局数组若不初始化，编译器将其初始化为零
  • 局部数组若不初始化，内容为随机值
c 复制代码 
#include <stdio.h>

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 数组名
  • 数组名是一个地址的常量，代表数组中首元素的地址
c 复制代码 
#include <stdio.h>

int main() {
    int a[] = {1, 3, 5, 7, 9}; // 内容，元素
    //         0  1  2  3  4   位置，下标
    // 数组名是一个地址的常量
    // a = NULL; // err
    // 代表数组中首元素的地址
    printf("a = %p, &a[0] = %p\n", 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]) = %d\n", sizeof(a), sizeof(&a[0]));
    // 求 元素个数    总大小 / 一个元素的大小
    printf("%d, %d\n", sizeof(a)/sizeof(int), sizeof(a)/sizeof(a[0]));

    return 0;
}

2.2 数组案例

2.2.1 一维数组的最大值
c 复制代码 
#include <stdio.h>
#include <stdlib.h> // srand()   rand()
#include <time.h>   // time()

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

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

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

    printf("max = %d\n", max);

    return 0;
}

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

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

    int m = rand() % 50 + 1;
    printf("m = %d\n", m);

    return 0;
}
2.2.2 一维数组的逆置
c 复制代码 
#include <stdio.h>
#include <stdlib.h> // srand()   rand()
#include <time.h>   // time()

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

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

    while(left < right) {
        temp = a[left];
        a[left] = a[right];
        a[right] = temp;
        left++;
        right--;
    }

    for (int i = 0; i < n; i++) {
        printf("%d, ", a[i]);
    }
    printf("\n");

    return 0;
}

2.3 数组和指针

2.3.1 通过指针操作数组元素
  • 数组名字是数组的首元素地址，但它是一个常量
  • * 和 [] 效果一样，都是操作指针所指向的内存
c 复制代码 
#include <stdio.h>

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, %d\n", *(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, %d\n", a, *p, *(p+0), p[0]);

    return 0;
}
2.3.2 指针数组
  • 指针数组，它是数组，数组的每个元素都是指针类型
c 复制代码 
#include <stdio.h>

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

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

    for (int i = 0; i < 3; i++) {
        printf("%d, %d, %d\n", *(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 数组名做函数参数
  • 数组名做函数参数，函数的形参本质上就是指针
c 复制代码 
#include <stdio.h>

// 数组名做函数参数，函数的形参本质上就是指针
void print_arr2(int a[5]) { // 形参数组，不是数组，是指针变量
    // a = NULL; // 是变量才能赋值
    // printf("形参的数组 sizeof(a) = %d\n", 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 < n; i++) {
        printf("%d, ", a[i]);
    }
    printf("\n");
}

int main() {
    int a[5] = {1, 3, 5, 7, 9};
    // 非形参的数组，是数组
    // a = NULL; // 数组名是常量
    printf("非形参的数组 sizeof(a) = %d\n", 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]
c 复制代码 
#include <stdio.h>

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(和字符 '\0' 等价)结尾的char数组就是一个字符串，字符串是一种特殊的char的数组
  • 如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组
c 复制代码 
#include <stdio.h>

int main() {
    // 1. 普通字符数组，没有结束符'\0'或数字0
    char s1[] = {'a', 'b', 'c'};
     // %s 打印的原理，从第一个字符开始打印，直到遇到结束符，停止打印
    printf("s1 = %s\n", s1);
    // 2. 字符串，有结束符'\0'或数字0
    char s2[] = {'a', 'b', 'c', '\0'};
    char s3[] = {'a', 'b', 'c', 0};
    // %s 打印的原理，从第一个字符开始打印，直到遇到结束符，停止打印
    printf("s2 = %s\n", s2);
    printf("s3 = %s\n", s3);
    // 3. 区分 字符数组 还是 字符串
    char s4[3] = {'a', 'b', 'c'}; // 数组
    char s5[4] = {'a', 'b', 'c'}; // 串， 只初始化3个元素，没有初始化的赋值为0
    // 4. 重点， 字符串方式初始化
    char s6[] = "abc"; // 双引号，默认隐藏了结束符
    char s7[] = {'a', 'b', 'c', '\0'}; // s6和s7等价，不同的写法
    printf("%s, %s\n", s6, s7);

    return 0;
}
2.4.2 字符串输入
c 复制代码 
#include <stdio.h>

int main() {
    char name[15];
    printf("请输入姓名:");
    scanf("%s", name); // 不是修改name，给分别给name的元素赋值
    // scanf("%s", &name[0]);
    printf("name = %s\n", name);

    return 0;
}
2.4.3 字符指针
  • 字符指针可直接赋值为字符串，保存的实际上是字符串的首地址
  • 此时，字符串指针所指向的内存不能修改，指针变量本身可以修改
c 复制代码 
#include <stdio.h>

int main() {
    char s1[] = "abc"; // 双引号，默认隐藏了结束符
    //           012
    // char s2[] = {'a', 'b', 'c', '\0'}; // s1和s2等价，不同的写法
    // 保存首元素地址，首元素是char，需要char *
    char * p = s1; // char * p = &s1[0];  // 指向数组首元素，数组的元素本身可以改的，也可以通过指针间接修改
    p[0] = 'x';
    printf("s1 = %s\n", s1);

    // 字符指针 可以 直接指向字符串，字符串本身是常量，不可以通过指针间接修改字符串的元素
    char * p2 = "hello";
    //           0
    // p2[0] = 'x'; // err
    printf("p2 = %s\n", p2);

    return 0;
}
2.4.4 字符串常用库函数

功能，参数，返回值

strlen
  • 功能：计算字符串的长度（不包含末尾的终止符 '\0'）。
  • 参数：const char *str（指向待计算长度的字符串的指针）。
  • 返回值：size_t（无符号整数，表示字符串中字符的个数）。
c 复制代码 
#include <string.h>
char str[] = "hello";
printf("%zu", strlen(str));  // 输出：5（不含'\0'）
strcpy
  • 功能：将源字符串（包括 '\0'）复制到目标字符串。
  • 参数：
    • char *dest（指向目标字符串的指针）
    • const char *src（指向源字符串的指针）
  • 返回值：char *（指向目标字符串 dest 的指针）。 注意：需确保目标字符串有足够空间，否则会导致缓冲区溢出。
c 复制代码 
char dest[20];
char src[] = "world";
strcpy(dest, src);  // dest 变为 "world"（包含'\0'）
strcat
  • 功能：将源字符串追加到目标字符串的末尾（覆盖目标字符串原有的 '\0'，并在新字符串末尾添加 '\0'）。
  • 参数：
    • char *dest（指向目标字符串的指针）
    • const char *src（指向源字符串的指针）
  • 返回值：char *（指向目标字符串 dest 的指针）。 注意：需确保目标字符串有足够空间容纳拼接后的结果。
c 复制代码 
char dest[20] = "hello";
char src[] = "world";
strcat(dest, src);  // dest 变为 "helloworld"
strcmp
  • 功能：比较两个字符串（按 ASCII 码值逐个字符比较）。
  • 参数：
    • const char *str1（指向第一个字符串的指针）
    • const char *str2（指向第二个字符串的指针）
  • 返回值：
    • 若 str1 > str2：返回正整数
    • 若 str1 == str2：返回 0
    • 若 str1 < str2：返回负整数
c 复制代码 
printf("%d", strcmp("apple", "banana"));  // 输出负数（'a' < 'b'）
printf("%d", strcmp("hello", "hello"));   // 输出 0（相等）
2.4.5 字符串案例
  • 需求：自定义一个函数my_strlen()，实现的功能和strlen一样

实现思路：

  • 遍历字符串，从首字符开始计数
  • 遇到终止符 '\0' 时停止计数
  • 返回计数结果
c 复制代码 
#include <stdio.h>

// 自定义字符串长度计算函数
size_t my_strlen(const char *str) {
    size_t len = 0;  // 计数器，初始化为0
    
    // 遍历字符串，直到遇到'\0'
    while (str[len] != '\0') {
        len++;  // 每多一个字符，长度+1
    }
    
    return len;  // 返回计算的长度
}

// 测试函数
int main() {
    char str1[] = "hello world";
    char str2[] = "";  // 空字符串
    char str3[] = "a";
    
    printf("my_strlen(\"%s\") = %zu\n", str1, my_strlen(str1));  // 输出：11
    printf("my_strlen(\"%s\") = %zu\n", str2, my_strlen(str2));  // 输出：0
    printf("my_strlen(\"%s\") = %zu\n", str3, my_strlen(str3));  // 输出：1
    
    return 0;
}

三、结构体

在 C 语言中，结构体是一种自定义用户自定义数据类型，允许将不同类型的数据组合成一个整体，用于表示具有多个相关属性的复杂对象（如学生、书籍、坐标等）。

c 复制代码 
struct 结构体名 {
    数据类型 成员名1;
    数据类型 成员名2;
    // ... 更多成员
};

3.1 结构体的使用

c 复制代码 
#include <stdio.h>

// 结构体：复合类型(多个类型的集合)，自定义类型
// 类型定义  struct  结构体名字
// struct Student 合在一起，才是类型
struct Student{
    char name[30];
    int age;
    char sex;
};

int main() {
    // 结构体类型  变量
    struct Student s = {"mike", 18, 'm'};  // 初始化
    // 如果是普通变量  用. 访问成员
    printf("%s, %d, %c\n", s.name, s.age, s.sex);
    // 如果是指针变量，用->访问成员
    struct Student * p;
    p = &s;
    printf("%s, %d, %c\n", p->name, p->age, p->sex);

    return 0;
}

3.2 结构体值传参

  • 传值是指将参数的值拷贝一份传递给函数，函数内部对该参数的修改不会影响到原来的变量
c 复制代码 
#include <stdio.h>
#include <string.h> // strcpy()

struct Student{
    char name[30];
    int age;
    char sex;
};

void func(struct Student s) {
    strcpy(s.name, "tom");
    s.age = 22;
    s.sex = 'm';
    printf("函数里面：%s, %d, %c\n", s.name, s.age, s.sex);
}

int main() {
    // 结构体类型   变量
    struct Student s = {"mike", 18, 'm'};
    // 通过一个函数，修改成员
    func(s); // 传递是变量本身，没有加&，叫值传递
    printf("调用函数后：%s, %d, %c\n", s.name, s.age, s.sex);

    return 0;
}

3.3 结构体地址传递

  • 传址是指将参数的地址传递给函数，函数内部可以通过该地址来访问原变量，并对其进行修改。
c 复制代码 
#include <stdio.h>
#include <string.h> // strcpy()

struct Student{
    char name[30];
    int age;
    char sex;
};

void func(struct Student * p) {
    strcpy(p->name, "tom");
    p->age = 22;
    p->sex = 'm';
    printf("函数里面：%s, %d, %c\n", p->name, p->age, p->sex);
}

int main() {
    // 结构体类型   变量
    struct Student s = {"mike", 18, 'm'};
    // 通过一个函数，修改成员
    func(&s); // 传递是变量加&，叫地址传递
    printf("调用函数后：%s, %d, %c\n", s.name, s.age, s.sex);

    return 0;
}
相关推荐
艾莉丝努力练剑2 分钟前
【C语言16天强化训练】从基础入门到进阶：Day 5
c语言·c++·学习·算法
Ustinian_3105 小时前
【C/C++】For 循环展开与性能优化【附代码讲解】
c语言·开发语言·c++
tt55555555555516 小时前
C/C++嵌入式笔试核心考点精解
c语言·开发语言·c++
科大饭桶17 小时前
C++入门自学Day14-- Stack和Queue的自实现（适配器）
c语言·开发语言·数据结构·c++·容器
肉夹馍不加青椒1 天前
第三十三天（信号量）
java·c语言·算法
古译汉书1 天前
嵌入式-SPI番外之按钮驱动程序的编写-Day15
c语言·stm32·单片机·嵌入式硬件·mcu·算法
knd_max1 天前
C语言：字符函数与字符串函数（1）
c语言
444A4E1 天前
深入理解Linux进程管理：从创建到替换的完整指南
linux·c语言·操作系统
敲上瘾1 天前
Linux I/O 多路复用实战：Select/Poll 编程指南
linux·服务器·c语言·c++·select·tcp·poll
热门推荐
01UV安装并设置国内源02Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code03KGG转MP3工具|非KGM文件|解密音频04DeepSeek更新！速览DeepSeek V3.1新特性05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接06Claude Code VSCode集成开发指南：AI编程助手完整配置07【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）08Spring 调试终于不再痛苦了092025最新国内服务器可用docker源仓库地址大全（2025年8月更新）10NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南