【C 语言】二级指针案例 ( 字符串切割 | 返回 自定义二级指针 作为结果 | 每个 一级指针 指向不同大小内存 | 精准分配每个 一级指针 指向的内存大小 )

简介: 【C 语言】二级指针案例 ( 字符串切割 | 返回 自定义二级指针 作为结果 | 每个 一级指针 指向不同大小内存 | 精准分配每个 一级指针 指向的内存大小 )

文章目录

一、二级指针案例 ( 返回自定义二级指针 | 精准控制内存大小 )

二、完整代码示例





一、二级指针案例 ( 返回自定义二级指针 | 精准控制内存大小 )


博客 【C 语言】二级指针案例 ( 字符串切割 | 返回 二维数组 作为结果 ) 中 , 使用 二维数组 , 接收字符串切割结果 ;


博客 【C 语言】二级指针案例 ( 字符串切割 | 返回 自定义二级指针 作为结果 ) 中 , 使用 自定义二级指针 , 接收字符串切割结果 ;



先分析出该 字符串中, 有多少个 逗号 字符 , 可以得到 二级指针 指向的 内存空间中 , 要存储多少 一级指针 , 也就是分析出有多少 行 , 然后在分析 每行 有多少列 , 即 为每个 一级指针 分配多少内存 ;


上述分配方式 , 能精准控制 内存 , 最大限度利用内存 ;



扫描 2 22 遍 ,


第一遍扫描 , 求出有多少个 一级指针 , 并为其分配内存 ;

第二次扫描 , 求出每个 一级指针 要分配多少内存 ;


第一次扫描 : 计算 要分割的字符串 个数 , 为其分配内存 ;


 

// 第一次遍历 , 求出有多少行
    do
    {
        // 字符串中, 查找 字符 ','
        // 找到后 , 返回 逗号 第一次出现的指针
        p1 = strchr(p1, c);
        if (p1 != NULL)
        {
            // 将 p1 指针 与 p2 指针之间的 字符拷贝出来
            // 这就是分割后的字符串
            if (p1 - p2 > 0)
            {
                tmpcount ++;
                p1 = p2 = p1 + 1;
            }
        }
        else
        {
            // 如果 p1 为 NULL , 说明没有找到逗号字符 , 退出循环即可
            break;
        }
    } while (*p1 != '\0');
    // 得到分割的字符串个数
    *count = tmpcount;
    // 为 一级指针 分配内存
    p = (char **) malloc(tmpcount * sizeof(char *) );
    if (myp == NULL)
    {
        return -1;
    }
    // 初始化分配的内存
    memset(p, 0, tmpcount * sizeof(char *));



第二次扫描 : 为每个 一级指针 分配对应的内存 , 并拷贝 分割后的 字符串 ;


// 第二次遍历
    // p1 , p2 初始化
    p1 = str;
    p2 = str;
    tmpcount = 0;
    do
    {
        // 字符串中, 查找 字符 ','
        // 找到后 , 返回 逗号 第一次出现的指针
        p1 = strchr(p1, c);
        if (p1 != NULL)
        {
            // 将 p1 指针 与 p2 指针之间的 字符拷贝出来
            // 这就是分割后的字符串
            if (p1 - p2 > 0)
            {
                // 计算精准控制的 一级指针 指向的内存大小
                int len = p1 - p2 + 1;
                // 为 一级指针 分配内存
                p[tmpcount] = (char *) malloc(len * sizeof(char));
                if(p[tmpcount] == NULL)
                {
                    return -1;
                }
                // 将 p2 后的 p1 - p2 个字符
                // 拷贝到数组中
                strncpy(p[tmpcount], p2,  p1 - p2);
                // 实际的字符拷贝完成后 , 再将 '\0' 字符拷贝过去
                p[tmpcount][p1-p2]  = '\0';
                // 拷贝完成后 , 字符
                tmpcount ++;
                // p2 和 p1 都设置为 指向 逗号后面字符
                // 重新开始查找 逗号 并分割
                p2 = p1 = p1 + 1;
            }
        }
        else
        {
            // 如果 p1 为 NULL , 说明没有找到逗号字符 , 退出循环即可
            break;
        }
    } while (*p1 != '\0');
    // 通过间接赋值 设置 分割后的字符串 到 自定义二级指针
    *myp = p;






二、完整代码示例


完整代码示例 :


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
 * @brief split_str 分割字符串
 * @param str 要分割的字符串
 * @param c 分割依据
 * @param p 将分割结果写入该二级指针内存
 * @param count 分割了多少份
 * @return
 */
int split_str(const char *str, char c, char ***myp, int *count)
{
    // 用于接收 str 参数
    char *p1 = NULL, *p2 = NULL;
    // 临时变量
    int tmpcount = 0;
    // 自定义的二级指针
    char **p = NULL;
    // p1 , p2 初始化
    p1 = str;
    p2 = str;
    // 第一次遍历 , 求出有多少行
    do
    {
        // 字符串中, 查找 字符 ','
        // 找到后 , 返回 逗号 第一次出现的指针
        p1 = strchr(p1, c);
        if (p1 != NULL)
        {
            // 将 p1 指针 与 p2 指针之间的 字符拷贝出来
            // 这就是分割后的字符串
            if (p1 - p2 > 0)
            {
                tmpcount ++;
                p1 = p2 = p1 + 1;
            }
        }
        else
        {
            // 如果 p1 为 NULL , 说明没有找到逗号字符 , 退出循环即可
            break;
        }
    } while (*p1 != '\0');
    // 得到分割的字符串个数
    *count = tmpcount;
    // 为 一级指针 分配内存
    p = (char **) malloc(tmpcount * sizeof(char *) );
    if (myp == NULL)
    {
        return -1;
    }
    // 初始化分配的内存
    //memset(p, 0, tmpcount * sizeof(char *));
    // 第二次遍历
    // p1 , p2 初始化
    p1 = str;
    p2 = str;
    tmpcount = 0;
    do
    {
        // 字符串中, 查找 字符 ','
        // 找到后 , 返回 逗号 第一次出现的指针
        p1 = strchr(p1, c);
        if (p1 != NULL)
        {
            // 将 p1 指针 与 p2 指针之间的 字符拷贝出来
            // 这就是分割后的字符串
            if (p1 - p2 > 0)
            {
                // 计算精准控制的 一级指针 指向的内存大小
                int len = p1 - p2 + 1;
                // 为 一级指针 分配内存
                p[tmpcount] = (char *) malloc(len * sizeof(char));
                if(p[tmpcount] == NULL)
                {
                    return -1;
                }
                // 将 p2 后的 p1 - p2 个字符
                // 拷贝到数组中
                strncpy(p[tmpcount], p2,  p1 - p2);
                // 实际的字符拷贝完成后 , 再将 '\0' 字符拷贝过去
                p[tmpcount][p1-p2]  = '\0';
                // 拷贝完成后 , 字符
                tmpcount ++;
                // p2 和 p1 都设置为 指向 逗号后面字符
                // 重新开始查找 逗号 并分割
                p2 = p1 = p1 + 1;
            }
        }
        else
        {
            // 如果 p1 为 NULL , 说明没有找到逗号字符 , 退出循环即可
            break;
        }
    } while (*p1 != '\0');
    // 通过间接赋值 设置 分割后的字符串 到 自定义二级指针
    *myp = p;
    return 0;
}
/**
 * @brief 主函数入口
 * @return
 */
int main()
{
    // 存放返回值
    int ret = 0;
    // 字符串分割的份数
    int count = 4;
    // 按照逗号分割
    char split = ',';
    // 字符串
    char *str = "12,ab,345,";
    // 循环控制变量
    int i = 0;
    // 存放分割结果, 此处自定义 二级指针 内存结构
    char **p = NULL;
    // 分割字符串
    ret = split_str(str, split, &p, &count);
    // split_str 方法执行失败
    if(ret != 0)
    {
        printf("split error!\n");
        return ret;
    }
    // 打印分割结果
    for(i = 0; i < count; i++)
    {
        printf("%s\n", p[i]);
    }
    // 释放内存
    // 先释放 num 个 一级指针
    for(i = 0; i < count; i++)
    {
        if(p[i] != NULL)
        {
            free(p[i]);
            p[i] = NULL;
        }
    }
    // 再释放 二级指针
    if(p != NULL)
    {
        free(p);
    }
    // 二维指针 置空
    p = NULL;
    // 命令行不要退出
    system("pause");
    return 0;
}


执行结果 :


image.png

目录
相关文章
|
2月前
|
存储 安全 Java
【Golang】(4)Go里面的指针如何?函数与方法怎么不一样?带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据,是一种符合类型。Go抛弃了类与继承,同时也抛弃了构造方法,刻意弱化了面向对象的功能,Go并非是一个传统OOP的语言,但是Go依旧有着OOP的影子,通过结构体和方法也可以模拟出一个类。
165 1
|
4月前
|
存储 C++
C++语言中指针变量int和取值操作ptr详细说明。
总结起来,在 C++ 中正确理解和运用 int 类型地址及其相关取值、设定等操纵至关重要且基础性强:定义 int 类型 pointer 需加星号;初始化 pointer 需配合 & 取址;读写 pointer 执向之处需配合 * 解引用操纵进行。
400 12
|
5月前
|
安全 C语言
C语言中的字符、字符串及内存操作函数详细讲解
通过这些函数的正确使用,可以有效管理字符串和内存操作,它们是C语言编程中不可或缺的工具。
317 15
|
存储 C语言
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中,通过定义结构体并使用指向该结构体的指针,可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存,然后通过指针访问和修改结构体成员,最后用 `free` 释放内存,实现资源的有效管理。
1127 13
|
存储 缓存 监控
Docker容器性能调优的关键技巧,涵盖CPU、内存、网络及磁盘I/O的优化策略,结合实战案例,旨在帮助读者有效提升Docker容器的性能与稳定性。
本文介绍了Docker容器性能调优的关键技巧,涵盖CPU、内存、网络及磁盘I/O的优化策略,结合实战案例,旨在帮助读者有效提升Docker容器的性能与稳定性。
1085 7
|
缓存 算法 Java
本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制
在现代软件开发中,性能优化至关重要。本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制。通过调整垃圾回收器参数、优化堆大小与布局、使用对象池和缓存技术,开发者可显著提升应用性能和稳定性。
218 6
|
存储 C语言 C++
数据结构基础详解(C语言) 顺序表:顺序表静态分配和动态分配增删改查基本操作的基本介绍及c语言代码实现
本文介绍了顺序表的定义及其在C/C++中的实现方法。顺序表通过连续存储空间实现线性表,使逻辑上相邻的元素在物理位置上也相邻。文章详细描述了静态分配与动态分配两种方式下的顺序表定义、初始化、插入、删除、查找等基本操作,并提供了具体代码示例。静态分配方式下顺序表的长度固定,而动态分配则可根据需求调整大小。此外,还总结了顺序表的优点,如随机访问效率高、存储密度大,以及缺点,如扩展不便和插入删除操作成本高等特点。
837 5
|
NoSQL 程序员 Linux
轻踩一下就崩溃吗——踩内存案例分析
踩内存问题分析成本较高,尤其是低概率问题困难更大。本文详细分析并还原了两个由于动态库全局符号介入机制(it's a feature, not a bug)触发的踩内存案例。
|
Go
Golang语言高级数据类型之指针篇
这篇文章详细讲解了Golang语言中的指针概念、指针地址和类型、定义指针变量、指针的细节操作、指针传值,以及内置函数new和make的用法和它们之间的区别。
236 0
|
存储 安全 Go
深入理解 Go 语言中的指针类型
【8月更文挑战第31天】
240 0