【C 语言】结构体 ( 结构体中嵌套二级指针 | 为 结构体内的二级指针成员 分配内存 | 释放 结构体内的二级指针成员 内存 )

最新推荐文章于 2023-11-22 19:24:56 发布
最新推荐文章于 2023-11-22 19:24:56 发布
阅读量1.7k 收藏 18
点赞数 5
分类专栏： C 文章标签： C 结构体 结构体变量 结构体嵌套二级指针 结构体数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shulianghan/article/details/121667343
版权
C 专栏收录该内容
141 篇文章 86 订阅
订阅专栏

文章目录





一、结构体中嵌套二级指针



1、结构体中嵌套二级指针 类型声明


结构体中 嵌套 二级指针 , 二级指针 可以使用 指针数组 / 二维数组 / 自定义二级指针内存 三种内存模型的任意一种 ;

此处选择的模型是 自定义二级指针内存 ;


代码示例 :

/**
 * @brief The Student struct
 * 定义 结构体 数据类型 , 同时为该结构体类型声明 别名
 * 可以直接使用 别名 结构体变量名 声明结构体类型变量
 * 不需要在前面添加 struct 关键字
 */
typedef struct Student
{
    // 声明变量时 , 会自动分配这 5 字节内存
    // 赋值时 , 可以直接使用 = 赋值字符串
    char name[5];
    int age;
    int id;
    // 声明变量时 , 只会为 4 字节指针分配内存
    // 具体的 字符串内存 需要额外使用 malloc 申请内存
    // 赋值时 , 必须使用 strcpy 函数 , 向堆内存赋值
    char *address;

    // 学生小组成员 , 由多个字符串组成
    // 二级指针 , 指向多个 一级指针
    // 每个 一级指针 指向 一个字符串
    // 此处的 二级指针 可以使用 指针数组 / 二维数组 / 自定义二级指针内存
    // 此处选择的模型是 自定义二级指针内存
    char **team;
}Student;

2、为 结构体内的二级指针成员 分配内存


为二级指针成员分配内存时 , 先为二级指针分配内存 , 再为一级指针分配内存 ;

核心业务逻辑 :

    // 为每个结构体的 address 成员分配内存
    for(i = 0; i < count; i++)
    {
        // 为一级指针分配内存模型
        tmp[i].address = (char *)malloc(20);

        // 为 二级指针 内存模型分配内存 , 分配 3 个 一级指针 变量内存
        char **p = (char **)malloc(3 * sizeof(char *));

        // 为 二级指针 指向的 一级指针 分配内存
        for(j = 0; j < 3; j++)
        {
            // 每个一级指针分配 10 字节数据
            p[j] = (char *)malloc(10 * sizeof(char));
        }

        // 将分配好内存的 二级指针 模型 , 赋值给结构体中的二级指针
        tmp[i].team = p;
    }

代码示例 :

/**
 * @brief create_student 堆内存中分配内存
 * 为二级指针成员分配内存时 , 先为二级指针分配内存 , 再为一级指针分配内存
 * @param array 二级指针 , 指向结构体数组
 * @return
 */
int create_student(Student **array, int count)
{
    // 返回值
    int ret = 0;

    // 循环控制变量
    int i = 0, j = 0;

    // 临时变量
    Student *tmp = NULL;

    // 验证二级指针合法性
    if(array == NULL)
    {
        ret = -1;
        return ret;
    }

    // 堆内存中申请内存
    tmp = (Student *)malloc(sizeof(Student) * count);

    // 初始化分配的内存
    memset(tmp, 0, sizeof(Student) * count);

    // 为每个结构体的 address 成员分配内存
    for(i = 0; i < count; i++)
    {
        // 为一级指针分配内存模型
        tmp[i].address = (char *)malloc(20);

        // 为 二级指针 内存模型分配内存 , 分配 3 个 一级指针 变量内存
        char **p = (char **)malloc(3 * sizeof(char *));

        // 为 二级指针 指向的 一级指针 分配内存
        for(j = 0; j < 3; j++)
        {
            // 每个一级指针分配 10 字节数据
            p[j] = (char *)malloc(10 * sizeof(char));
        }

        // 将分配好内存的 二级指针 模型 , 赋值给结构体中的二级指针
        tmp[i].team = p;
    }

    // 通过间接赋值 设置返回值
    *array = tmp;

    return ret;
}

3、释放 结构体内的二级指针成员 内存


释放内存时 , 先释放 二级指针 指向的 一级指针 的内存 , 再释放 二级指针 内存 ;

核心业务逻辑 :

    // 释放 每个结构体的 address 成员分配内存
    for(i = 0; i < count; i++)
    {
        // 释放一级指针
        free((*array)[i].address);
        (*array)[i].address = NULL;

        // 释放二级指针指向的一级指针
        for(j = 0; j < 3; j++)
        {
            if((*array)[i].team[j] != NULL){
                free( (*array)[i].team[j] );
                (*array)[i].team[j] = NULL;
            }
        }

        // 释放二级指针
        if((*array)[i].team != NULL)
        {
            free( (*array)[i].team );
            (*array)[i].team = NULL;
        }
    }

代码示例 :

/**
 * @brief free_student 释放内存
 * 释放内存时 , 先释放 二级指针 指向的 一级指针 的内存 , 再释放 二级指针 内存
 * @param array
 * @return
 */
int free_student(Student **array, int count)
{
    // 返回值
    int ret = 0;

    // 循环控制变量
    int i = 0, j = 0;

    // 验证二级指针合法性
    if(array == NULL)
    {
        ret = -1;
        return ret;
    }

    // 释放 每个结构体的 address 成员分配内存
    for(i = 0; i < count; i++)
    {
        // 释放一级指针
        free((*array)[i].address);
        (*array)[i].address = NULL;

        // 释放二级指针指向的一级指针
        for(j = 0; j < 3; j++)
        {
            if((*array)[i].team[j] != NULL){
                free( (*array)[i].team[j] );
                (*array)[i].team[j] = NULL;
            }
        }

        // 释放二级指针
        if((*array)[i].team != NULL)
        {
            free( (*array)[i].team );
            (*array)[i].team = NULL;
        }
    }

    // 释放 结构体内存
    free(*array);

    // 指针置空 , 防止野指针
    *array = NULL;

    return ret;
}




二、完整代码示例


完整代码示例 :

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

/**
 * @brief The Student struct
 * 定义 结构体 数据类型 , 同时为该结构体类型声明 别名
 * 可以直接使用 别名 结构体变量名 声明结构体类型变量
 * 不需要在前面添加 struct 关键字
 */
typedef struct Student
{
    // 声明变量时 , 会自动分配这 5 字节内存
    // 赋值时 , 可以直接使用 = 赋值字符串
    char name[5];
    int age;
    int id;
    // 声明变量时 , 只会为 4 字节指针分配内存
    // 具体的 字符串内存 需要额外使用 malloc 申请内存
    // 赋值时 , 必须使用 strcpy 函数 , 向堆内存赋值
    char *address;

    // 学生小组成员 , 由多个字符串组成
    // 二级指针 , 指向多个 一级指针
    // 每个 一级指针 指向 一个字符串
    // 此处的 二级指针 可以使用 指针数组 / 二维数组 / 自定义二级指针内存
    // 此处选择的模型是 自定义二级指针内存
    char **team;
}Student;

/**
 * @brief printf_struct_array 打印结构体数组
 * @param array 数组作为函数参数退化为指针
 * @param count 数组中的元素个数
 */
void printf_struct_array(Student *array, int count)
{
    // 循环控制变量
    int i = 0;

    // 验证数组合法性
    if(array == NULL)
    {
        return;
    }

    // 打印结构体数组中的 结构体 age 字段
    for(i = 0; i < count; i++)
    {
        printf("Student age = %d\n", array[i].age);
    }
}

/**
 * @brief sort_struct_array 对结构体数组 按照年龄进行排序
 * @param array 结构体指针
 * @param count 结构体数组的元素个数
 */
void sort_struct_array(Student *array, int count)
{
    // 循环控制变量
    int i = 0, j = 0;
    // 学生年龄
    Student tmp;

    // 验证数组合法性
    if(array == NULL)
    {
        return;
    }

    // 排序
    for(i = 0; i < count; i++)
    {
        for(j = i + 1; j < count; j++)
        {
            if(array[i].age > array[j].age)
            {
                tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }
}

/**
 * @brief create_student 堆内存中分配内存
 * 为二级指针成员分配内存时 , 先为二级指针分配内存 , 再为一级指针分配内存
 * @param array 二级指针 , 指向结构体数组
 * @return
 */
int create_student(Student **array, int count)
{
    // 返回值
    int ret = 0;

    // 循环控制变量
    int i = 0, j = 0;

    // 临时变量
    Student *tmp = NULL;

    // 验证二级指针合法性
    if(array == NULL)
    {
        ret = -1;
        return ret;
    }

    // 堆内存中申请内存
    tmp = (Student *)malloc(sizeof(Student) * count);

    // 初始化分配的内存
    memset(tmp, 0, sizeof(Student) * count);

    // 为每个结构体的 address 成员分配内存
    for(i = 0; i < count; i++)
    {
        // 为一级指针分配内存模型
        tmp[i].address = (char *)malloc(20);

        // 为 二级指针 内存模型分配内存 , 分配 3 个 一级指针 变量内存
        char **p = (char **)malloc(3 * sizeof(char *));

        // 为 二级指针 指向的 一级指针 分配内存
        for(j = 0; j < 3; j++)
        {
            // 每个一级指针分配 10 字节数据
            p[j] = (char *)malloc(10 * sizeof(char));
        }

        // 将分配好内存的 二级指针 模型 , 赋值给结构体中的二级指针
        tmp[i].team = p;
    }

    // 通过间接赋值 设置返回值
    *array = tmp;

    return ret;
}

/**
 * @brief free_student 释放内存
 * 释放内存时 , 先释放 二级指针 指向的 一级指针 的内存 , 再释放 二级指针 内存
 * @param array
 * @return
 */
int free_student(Student **array, int count)
{
    // 返回值
    int ret = 0;

    // 循环控制变量
    int i = 0, j = 0;

    // 验证二级指针合法性
    if(array == NULL)
    {
        ret = -1;
        return ret;
    }

    // 释放 每个结构体的 address 成员分配内存
    for(i = 0; i < count; i++)
    {
        // 释放一级指针
        free((*array)[i].address);
        (*array)[i].address = NULL;

        // 释放二级指针指向的一级指针
        for(j = 0; j < 3; j++)
        {
            if((*array)[i].team[j] != NULL){
                free( (*array)[i].team[j] );
                (*array)[i].team[j] = NULL;
            }
        }

        // 释放二级指针
        if((*array)[i].team != NULL)
        {
            free( (*array)[i].team );
            (*array)[i].team = NULL;
        }
    }

    // 释放 结构体内存
    free(*array);

    // 指针置空 , 防止野指针
    *array = NULL;

    return ret;
}


/**
 * @brief 主函数入口
 * @return
 */
int main(int argc, char* argv[], char**env)
{

    // 声明结构体数组 , 该数组在栈内存中
    Student *array = NULL;
    // 循环控制变量
    int i = 0;

    // 堆内存中为结构体指针分配内存
    create_student(&array, 2);

    // 命令行中 , 接收输入的年龄
    for(i = 0; i < 2; i++)
    {
        // 命令换行中 接收 输入的年龄 ,
        // 设置到 Student 数组元素的 age 成员中
        printf("\n Input Age :\n");
        scanf("%d", &(array[i].age));

        printf("\n Input ID :\n");
        scanf("%d", &(array[i].id));

        printf("\n Input Name :\n");
        scanf("%s", array[i].name);

        printf("\n Input Address :\n");
        scanf("%s", array[i].address);

        printf("\n Input Team 1 Name :\n");
        scanf("%s", array[i].team[0]);

        printf("\n Input Team 2 Name :\n");
        scanf("%s", array[i].team[1]);

        printf("\n Input Team 3 Name :\n");
        scanf("%s", array[i].team[2]);
    }

    // 结构体数组 按照 age 排序
    sort_struct_array(array, 2);

    // 打印结构体数组中的 结构体 age 字段
    printf_struct_array(array, 2);

    // 释放堆内存数据
    free_student(&array, 2);

    // 命令行不要退出
    system("pause");
    return 0;
}

执行结果 :


 Input Age :
18

 Input ID :
1

 Input Name :
Tom

 Input Address :
CHina

 Input Team 1 Name :
Tom1

 Input Team 2 Name :
Tom2

 Input Team 3 Name :
Tom3

 Input Age :
16

 Input ID :
2

 Input Name :
Jerry

 Input Address :
Beijing

 Input Team 1 Name :
Jerry1

 Input Team 2 Name :
Jerry2

 Input Team 3 Name :
Jerry3
Student age = 16
Student age = 18
请按任意键继续. . .

在这里插入图片描述

韩曙亮
关注
  • 5
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
结构体嵌套指针操作.txt
02-05
结构体嵌套一级和二级指针操作，包括创建，malloc资源释放,防止内存泄露等等，指针与数组，二级指针与数组等操作
（VS2010）C语言中用结构体变量和结构体变量指针分别输出结构体的每一个成员
qq_53609942的博客
04-04 2746
实验目的 用结构体变量和结构体变量指针分别输出结构体的每一个成员 实验要点 为了表示一些复杂的事物，普通的基本类型无法满足实际要求 结构体：把一些基本类型数据组合在一起形成一个新的复合数据类型 实验步骤 1.打开VS2010，创建新项目，选择空项目并命名，在源文件中添加新建项，选择C++文件并命名，后缀为.cpp 2.敲代码时先写出基础框架 # include <stdio.h> int main() { return 0; } 3.在纸上写出大致思路：首先定
【数据结构】深入浅出理解链表中二级指针的应用
最新发布
C/C++领域,数据结构,linux,MySQl学习者
11-22 1205
本文通过对单链表结构的分析,以及大量逻辑图示,物理图示详细解析了什么是二级指针?为什么链表要用到二级指针?为什么同样是链表的函数,有的要用二级指针而有的只要用一级指针?为什么同样是链表,有的链表中使用了二级指针?而有的函数却只需要使用一级指针?等问题.
结构体打印
kaiwawah的博客
07-22 7463
结构题是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量！
结构体嵌套二级指针
码云仓库地址：https://gitee.com/lance-gyq
05-07 158
结构体嵌套二级指针 代码示例： #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> struct Teacher { char *name; char**Students; }; void allocateSpace(struct Teacher***teachers) { struct Teacher
【C 语言】结构体 ( 结构体 数组 作为函数参数 | 数组 在 堆内存创建 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-01 815
一、结构体 数组 作为函数参数 ( 数组 在 堆内存创建 )、 二、完整代码示例
详解：指针、数组和函数的嵌套问题
初闻
09-03 3430
在学习C语言的过程中，我们经常会遇到一些数组和指针嵌套的问题，为了解决这些问题，我们首先要明确指针和数组之间是否有什么关系？ 强调：两者没有关系，指针是指针，数字是数组。 一、指针数组 表达式：int *p[5]; 说明：因为 [ ] 比 * 的优先级高，所以p首先与 [ ] 结合成为一个数组，再与 * 结合成为一个指针数组，数组的每一个元素都是一个指针（int * 类型）。 图解： ...
C语言 二级指针内存分配、初始化和释放
qq_40245400的博客
10-17 2025
c语言二级指针内存分配
C的实用笔记42——结构体二级指针
lzh201864031的博客
04-02 367
实际上是通过指针函数的返回值修改结构体指针的指向。3、，封装起来即可。
嵌套的指针数组程序图解，包含一级指针、二级指针、三级指针
Ljiyu0506的博客
05-25 273
cpp[-1][-1],相当于*(c[2] - 1)，指针向前走一步得到c[1]的地址，对其解引用得到，存储的字符串常量"NEW"首字母的地址；ccp[-2]，等同于*(ccp - 2)，指针ccp向前走两步，得到cp[0]的地址，对其解引用操作，得到存储的c[3]地址；cpp[-1],相当于*(cpp - 1)，指针向前走一步得到cp[1]的地址，对其解引用得到，存储的c[2]的地址；*(++ccp)，对cp[2]的地址进行解引用操作，得到存储的c[1]的地址；用画图的方式，模拟程序的运行。
二级c未来教育题库破解及资源
09-25
２.一维、二维数组和字符串的地址以及指向变量、数组、字符串、函数、结构体的指针变量的 定义。通过指针引用以上各类型数据。 ３.用指针作函数参数。 ４.返回地址值的函数。 ５.指针数组，指向指针的指针。 ...
C语言实例循环嵌套数组指针函数结构体
03-05
C语言的简单基本实例，包括循环、嵌套、数组、指针、函数、结构体等内容。
struct 结构体中数组和指针的操作
08-20
本文主要介绍在struct 结构体中对数组和指针的操作细节。
计算机语言中c/c++的基础入门学习代码记录（适应于计算机二级）
01-26
内含：博主学习记录 1.Hello 2.type（数据类型） 3.select（01if；02switch；...06结构体嵌套；07共用体） 10.位运算（01位运算；02位移运算；03位运算应用） 11.文件（01文件打开关闭；02文件读写）
【C 语言】文件操作 ( fwrite 函数 )
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
06-06 6万+
一、fwrite 函数、 二、fwrite 示例、 三、fwrite 示例 ( 写出数据超出实际有效值 )、 四、fwrite 示例 ( 输出 int 整型到二进制文件中 )、
【C 语言】文件操作 ( fread 函数 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-28 5万+
一、fread 函数、 二、缓冲区受限的情况 ( 循环读取文件 | feof 函数判定文件读取完毕 )、 三、处理乱码问题、 四、记录读取的字节个数、 五、读取到 0 字节的情况、 六、读取完毕的情况、 七、读取文本文件 "\n" 与 读取二进制文件 "\r\n" 区别、
【C 语言】文件操作 ( fopen 文件打开方式详解 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-27 4万+
r : 只读方式打开文件 , 文件必须存在 ; 文件不存在打开失败 ; + : 读写方式打开文件 ; w : 打开只写文件 , 文件不存在创建文件 , 文件存在覆盖文件 ; a : 打开只写文件 , 文件不存在创建文件 , 文件存在追加文件 ;
【C 语言】文件操作 ( fseek 函数 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-16 3万+
一、fseek 函数、 二、fseek 函数代码示例
【C 语言】文件操作 (fscanf、fprintf 函数)
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
05-27 1万+
一、fscanf 函数、 二、fprintf 函数
结构体数组用二级指针吗
09-12
引用中提到，结构体嵌套一级和二级指针操作可以包括创建、malloc资源释放、防止内存泄露等等操作。这意味着你可以使用一级指针或二级指针来操作结构体数组。 如果你选择使用一级指针来操作结构体数组，你可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值