欧阳铁柱大帅哥头像

C 语言进阶:二阶指针与结构体入门

1. 引言

今天的学习内容聚焦两个重点:二阶指针(指向指针的指针)和结构体(struct)。前者是 C 语言指针体系中承上启下的关键一环,后者则是迈向数据抽象与复杂数据结构的第一步。本文基于今天的学习笔记整理而成,先带你彻底吃透二阶指针,再通过一个完整的实战案例掌握结构体的用法,把这两个知识点串起来,形成完整的认知。

2. 二阶指针:指向指针的指针

2.1 什么是一阶指针

在理解二阶指针之前,先回顾一阶指针。一阶指针变量存储的是普通变量的地址,通过解引用(*)可以访问或修改该变量的值。只有把一阶指针理解透彻,才能顺利过渡到「指向指针的指针」。

一阶指针的定义

一阶指针,即指向普通变量的指针。它保存的是某个普通变量在内存中的地址,通过这个地址可以间接访问和修改该变量。定义时在类型名后加一个星号(*):

int a = 10;
int *p = &a;   // p 存储 a 的地址
*p = 20;       // 通过 p 修改 a 的值
一阶指针的组成

一个一阶指针变量包含两层含义:

  • 指针类型:int * 表示「指向 int 类型变量的指针」,决定了指针解引用后能访问的数据类型;
  • 指针值:指针变量本身存储的地址,即它指向哪个变量。
一阶指针的声明方式

声明一阶指针时,星号的位置比较灵活,以下三种写法等价:

int *p1;   // 星号靠近变量名
int* p2;   // 星号靠近类型名
int * p3;  // 星号居中

推荐统一使用 int *p 的写法,便于区分「指针类型」与「指针变量」。

一阶指针的初始化

指针在使用前必须初始化,否则它保存的是不确定的地址,解引用时可能访问非法内存。常见的初始化方式:

int a = 10;
int *p = &a;   // 用取地址运算符 & 初始化
int *q = NULL; // 空指针,表示不指向任何有效地址
一阶指针的解引用

通过 * 运算符可以访问指针所指向的变量:

int a = 10;
int *p = &a;
printf("%d\n", *p);  // 输出 10,*p 等价于 a
*p = 20;             // 修改 a 的值为 20
一阶指针的典型应用

一阶指针常用于函数参数传递,实现「传引用」效果,让函数内部修改外部变量的值:

#include <stdio.h>

void swap(int *x, int *y) {
    int temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int a = 3, b = 5;
    swap(&a, &b);
    printf("%d %d\n", a, b);  // 输出 5 3
    return 0;
}

如果不传指针而直接传值,函数内部交换的只是副本,外部变量不会改变。这正是指针存在的意义之一。

2.2 二阶指针的定义

二阶指针,即指向指针的指针(pointer to pointer)。它存储的是一阶指针变量的地址,而不是普通变量的地址。定义时使用两个星号:

int a = 10;
int *p = &a;    // 一阶指针
int **pp = &p;  // 二阶指针,存储 p 的地址
二阶指针的组成

二阶指针同样包含两层含义:

  • 指针类型:int ** 表示「指向 int * 类型指针的指针」,解引用一次得到一阶指针,解引用两次得到普通变量;
  • 指针值:二阶指针变量本身存储的是一阶指针变量的地址。
二阶指针的声明方式

声明二阶指针时使用两个星号,写法同样灵活:

int **pp1;   // 星号靠近变量名
int** pp2;   // 星号靠近类型名
int ** pp3;  // 星号居中

推荐统一使用 int **pp 的写法。

二阶指针的初始化

二阶指针必须指向一个一阶指针变量,而不是普通变量:

int a = 10;
int *p = &a;
int **pp = &p;   // 正确:pp 存储 p 的地址
// int **pp = &a; // 错误:&a 是 int* 类型,不能直接赋给 int**
二阶指针的解引用

二阶指针经过一次解引用得到一阶指针,经过两次解引用得到普通变量的值:

*pp   // 等价于 p,即 a 的地址
**pp  // 等价于 *p,即 a 的值 10
二阶指针的层级关系

从内存角度看,三者形成一条「地址链」:

  • a 是普通变量,值为 10,地址为 &a;
  • p 是一阶指针,存储 &a,地址为 &p;
  • pp 是二阶指针,存储 &p。

可以用一张图来理解:

存储 &p

存储 &a

值为 10

pp 变量

p 变量

a 变量

内存单元

为什么需要二阶指针

一阶指针已经能修改普通变量的值,但无法修改「指针变量本身」的指向。当函数需要改变调用方指针变量的指向时,就必须传入该指针变量的地址,也就是二阶指针。这是二阶指针最核心的存在意义,也是它与一阶指针最本质的区别。

2.3 二阶指针的典型应用

二阶指针最常见的应用场景是在函数中修改传入指针本身的值。如果函数需要改变调用方指针变量的指向,就必须传入指针的地址,即二阶指针。

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

void allocMemory(int **pp) {
    *pp = (int *)malloc(sizeof(int));
    **pp = 100;
}

int main() {
    int *p = NULL;
    allocMemory(&p);   // 传入指针的地址
    printf("%d\n", *p); // 输出 100
    free(p);
    return 0;
}

如果不使用二阶指针,函数内部对指针的修改无法反映到调用方,这正是二阶指针存在的意义。

2.4 二阶指针的典型应用

二阶指针最常见的应用场景是在函数中修改传入指针本身的值。如果函数需要改变调用方指针变量的指向,就必须传入指针的地址,即二阶指针。

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

void allocMemory(int **pp) {
    *pp = (int *)malloc(sizeof(int));
    **pp = 100;
}

int main() {
    int *p = NULL;
    allocMemory(&p);   // 传入指针的地址
    printf("%d\n", *p); // 输出 100
    free(p);
    return 0;
}

如果不使用二阶指针,函数内部对指针的修改无法反映到调用方,这正是二阶指针存在的意义。

3. 结构体:从零开始认识

3.1 为什么需要结构体

基本数据类型(int、char、float 等)只能描述单一属性。现实中的对象往往包含多个属性,例如一个学生有学号、姓名、年龄、成绩。结构体允许我们把多个不同类型的数据组合成一个整体,便于统一管理和传递。

3.2 结构体的定义与声明

使用 struct 关键字定义结构体类型:

struct Student {
    int id;          // 学号
    char name[20];   // 姓名
    int age;         // 年龄
    float score;     // 成绩
};

定义结构体类型后,就可以声明结构体变量:

struct Student stu1;
struct Student stu2 = {1001, "张三", 18, 92.5};

3.3 访问结构体成员

通过点运算符(.)访问结构体变量的成员:

stu1.id = 1002;
stu1.age = 19;
printf("姓名:%s,成绩:%.1f\n", stu2.name, stu2.score);

3.4 结构体数组

结构体数组用于管理多个同类型的对象,例如一个班级的多个学生:

struct Student class[3] = {
    {1001, "张三", 18, 92.5},
    {1002, "李四", 19, 88.0},
    {1003, "王五", 18, 95.0}
};

for (int i = 0; i < 3; i++) {
    printf("%d %s %.1f\n", class[i].id, class[i].name, class[i].score);
}

3.5 结构体实战案例:学生成绩管理系统

下面通过一个完整的实战案例,把前面学到的结构体知识串起来:定义结构体、声明变量、访问成员、使用结构体数组,并配合函数实现一个简单的学生成绩管理系统。

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

#define MAX_STUDENTS 50

struct Student {
    int id;          // 学号
    char name[20];   // 姓名
    int age;         // 年龄
    float score;     // 成绩
};

// 录入一个学生信息
void inputStudent(struct Student *pStu) {
    printf("请输入学号:");
    scanf("%d", &pStu->id);
    printf("请输入姓名:");
    scanf("%s", pStu->name);
    printf("请输入年龄:");
    scanf("%d", &pStu->age);
    printf("请输入成绩:");
    scanf("%f", &pStu->score);
}

// 打印一个学生信息
void printStudent(struct Student stu) {
    printf("%d\t%s\t%d\t%.1f\n", stu.id, stu.name, stu.age, stu.score);
}

// 计算全班平均成绩
float averageScore(struct Student class[], int n) {
    float sum = 0;
    for (int i = 0; i < n; i++) {
        sum += class[i].score;
    }
    return n > 0 ? sum / n : 0;
}

// 找出成绩最高的学生
int findTopStudent(struct Student class[], int n) {
    int top = 0;
    for (int i = 1; i < n; i++) {
        if (class[i].score > class[top].score) {
            top = i;
        }
    }
    return top;
}

int main() {
    struct Student class[MAX_STUDENTS];
    int n;

    printf("请输入学生人数:");
    scanf("%d", &n);

    // 录入所有学生信息
    for (int i = 0; i < n; i++) {
        printf("\n--- 录入第 %d 个学生 ---\n", i + 1);
        inputStudent(&class[i]);
    }

    // 打印所有学生信息
    printf("\n学号\t姓名\t年龄\t成绩\n");
    for (int i = 0; i < n; i++) {
        printStudent(class[i]);
    }

    // 输出平均成绩和最高分
    printf("\n全班平均成绩:%.1f\n", averageScore(class, n));
    int top = findTopStudent(class, n);
    printf("成绩最高的学生:%s,成绩 %.1f\n", class[top].name, class[top].score);

    return 0;
}

这个案例综合运用了结构体的多个知识点:

  • 结构体指针传参:inputStudent(struct Student *pStu) 通过指针修改结构体成员,实现「传引用」效果;
  • 结构体值传参:printStudent(struct Student stu) 直接传值,适合只读场景;
  • 结构体数组:class[MAX_STUDENTS] 管理多个学生对象,配合循环完成批量录入与输出;
  • 函数封装:把录入、打印、求平均、找最高分等操作封装成独立函数,让主函数逻辑清晰。

运行效果示例:

请输入学生人数:3

--- 录入第 1 个学生 ---
请输入学号:1001
请输入姓名:张三
请输入年龄:18
请输入成绩:92.5

--- 录入第 2 个学生 ---
请输入学号:1002
请输入姓名:李四
请输入年龄:19
请输入成绩:88.0

--- 录入第 3 个学生 ---
请输入学号:1003
请输入姓名:王五
请输入年龄:18
请输入成绩:95.0

学号    姓名    年龄    成绩
1001    张三    18      92.5
1002    李四    19      88.0
1003    王五    18      95.0

全班平均成绩:91.8
成绩最高的学生:王五,成绩 95.0

通过这个实战案例,可以看到结构体如何把零散的数据组织成有意义的整体,再配合数组和函数,就能写出真正可用的管理程序。这也是后续学习链表、动态内存管理等进阶内容的基础。

5. 今日小结

今天完成了二阶指针的学习,掌握了它的定义、解引用方式以及「在函数中修改指针本身」的核心应用场景;同时对结构体有了初步认识,学会了定义结构体类型、声明变量、访问成员、使用结构体数组和结构体指针。

下一步建议继续深入学习结构体与指针的配合(如链表)、typedef 简化结构体声明,以及动态内存管理与结构体的综合应用。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/Ouyangtiezhusg/article/details/167282621

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--