详解C语言-二级指针三种内存模型

短命女 2023-02-16 10:52 29阅读 0赞

二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别

第一种内存模型char \*arr\[\]

若有如下定义

char *arr[] = {"abc", "def", "ghi"};

这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char \* \[\]），数组的每个元素都是一个地址。

其实做为一个学习者，有一个学习的氛围跟一个交流圈子特别重要这里我推荐一个C语言C++交流群1075673198，不管你是小白还是转行人士欢迎入驻，大家一起交流成长。

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为

char *tmp = NULL;

如果要打印这个数组，那么可以使用以下函数

int i = 0;
    	if (pArray == NULL)
    	{
    		return -1;
    	}
    	for (i = 0; i < num; i++)
    	{
    		printf("%s \n", pArray[i]);
    	}
    	return 0;
    }

第二种内存模型char arr\[\]\[\]

若有如下定义

char arr[3][5] = {"abc", "def", "ghi"};

种模型为二级指针的第二种内存模型，在理解的时候应该这样理解：定义了一个二维数组，有3个（5个char）空间的存储变量。

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为

char tmp[5] = { 0 };

如果要打印这个数组，那么可以使用以下函数

nt printAarray(char pArray[][5], int num) {
    	int i = 0;
    	if (pArray == NULL)
    	{
    		return -1;
    	}
    	for (i = 0; i < num; i++)
    	{
    		printf("%s \n", pArray[i]);
    	}
    	return 0;
    }

第三种内存模型char \*\*arr

若有如下定义

char **arr = (char *)malloc(100 * sizeof(char *));//char arr[400]
    arr[0] = (char *)malloc(100 * sizeof(char));//char buf[100]
    arr[1] = (char *)malloc(100 * sizeof(char));
    arr[2] = (char *)malloc(100 * sizeof(char));
    strcpy(arr[0], "abc");
    strcpy(arr[1], "def");
    strcpy(arr[2], "ghi");
    ···
    for(int i = 0; i < 3; i++)
      if(arr[i] != NULL)
        free(arr[i]);
    free(arr);

这种模型为二级指针的第二种内存模型，在理解的时候应该这样理解：定义了一个二级指针，二级指针就是指向指针的指针，其实就是开辟了100个指针空间，存放了100个地址。这种写法是第一种的简化写法

在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为

char *tmp = NULL

如果要打印这个数组，那么可以使用以下函数

{
    	int i = 0;
    	if (pArray == NULL)
    	{
    		return -1;
    	}
    	for (i = 0; i < num; i++)
    	{
    		printf("%s \n", pArray[i]);
    	}
    	return 0;
    }

例子

把第一种内存模型的数据排序,运算结果放到第三种内存模型中

include "stdio.h"
    #include "string.h"
    #include "stdlib.h"
    
    char **SortArrayAndGen3Mem(const char ** const myArray1, int num, char *str, int *myNum) {
    	char **p = NULL;
    		p= (char **)malloc(num*sizeof(char *));
    	if (myArray1==NULL || str==NULL|| myNum==NULL)
    	{
    		printf("传入参数错误\n");
    		p = NULL;
    		goto END;
    	}
    	*myNum = num;
    	for (int i = 0; i < num;i++)
    	{
    		p[i] = NULL;
    		p[i] = (char)malloc(50 * sizeof(char));
    		memset(p[i], 0, sizeof(p[i]));
    		if (p[i]==NULL)
    		{
    			printf("内存分配错误！\n");
    			goto END;
    		}
    		strcpy(p[i], myArray1[i]);
    	}
    	char *tmp;
    	for (int i = 0; i < num; i++)
    	{
    		for (int j = i + 1; j < num; j++)
    		{
    			if (strcmp(p[i],p[j])>0)
    			{
    				char *tmp = p[i];
    				p[i] = p[j];
    				p[j] = tmp;
    			}
    		}
    	}
    	for (int i = 0; i < num; i++)
    	{
    		printf("%s \n", myArray1[i]);
    	}
    
    END:
    	return p;
    }
    
    //释放内存函数
    
    void main() {
    	int i = 0;
    	char **myArray3 = NULL;
    	int num3 = 0;
    	//第一种内存模型
    	char *myArray[] = {"bbbbb", "aaaaa", "cccccc"};
    	char *myp = "111111111111";
    
    	myArray3 = SortArrayAndGen3Mem(myArray, 3, myp, &num3);
    
    	for (i=0; i<num3; i++)
    	{
    		printf("%s \n", myArray3[i]);
    	}
    
    	system("pause");
    }
    #include "stdio.h"
    #include "stdlib.h"
    #include "string.h"
    
    char **SortArrayAndGet3Mem(const char* const myArray1,int num,char *str,int *myNum);
    int getArray(char ***newp,int num) ;
    int freeArray(char ***newpfree,int num);
    int sortTArray(char *p, int num);
    
    void main() {
    	char **myArray3=NULL;
    	int num3=0;
    	char *myArray[]={"bbbb","aaa","cccc"};
    	char *myp="111111111";
    	myArray3=SortArrayAndGet3Mem(myArray,3,myp,&num3);
    	system("pause");
    }
    
    char **SortArrayAndGet3Mem(const char** const myArray1,int num,char *str,int *myNum) {
    	int ret=0;
    	char **p=NULL;
    	int i=0;
    	char **p1=NULL;
    	p1=(char **)myArray1;
    	ret=getArray(&p,num +1);
    	for (i=0;i<num;i++)
    	{
    		strcpy(p[i],p1[i]);
    	}
    	strcpy(p[i], str);
    	ret=sortTArray(p,num +1);
    	for (i=0;i<num +1;i++)
    	{
    		printf("%s\n",p[i]);
    	}
    	ret=freeArray(&p,num +1);
    	*myNum = num +1;
    	return p;
    }
    
    int getArray(char ***newp,int num) {
    	int i=0;
    	int ret=0;
    	char **tmp = NULL;
    	tmp = (char **)malloc(num*sizeof(char *));
    	for (i=0;i<num;i++)
    	{
    		tmp[i]=(char*)malloc(sizeof(char)*100);
    	}
    	*newp = tmp; //
    	return 0;
    }
    
    //
    int freeArray(char ***newpfree,int num) {
    	char **p=NULL;
    	int i=0;
    	int ret=0;
    	p=*newpfree;
    	for (i=0;i<num;i++)
    	{
    		free(p[i]);
    	}
    	free(p);
    	*newpfree = NULL; //
    	return ret;
    }
    
    //int sortTArray(char ***Arraystr, int num)
    int sortTArray(char **Arraystr, int num) {
    	int i , j = 0;
    	for (i=0; i<num; i++)
    	{
    		for (j=i+1; j<num; j++)
    		{
    			if (strcmp((Arraystr)[i],(Arraystr)[j])>0)
    			{
    				char tmp[100];
    				strcpy(tmp,(Arraystr)[i]);
    				strcpy((Arraystr)[i],(Arraystr)[j]);
    				strcpy((Arraystr)[j],tmp);
    			}
    		}
    	}
    	for (i=0;i<num;i++)
    	{
    		printf("%s\n",(Arraystr)[i]);
    	}
    	return 0;
    }

时间：2020-06-09

[javascript 内存模型实例详解][javascript]

本文实例讲述了javascript 内存模型.分享给大家供大家参考,具体如下: 我对于 JavaScript 的内存模型一直都比较困惑,很想了解在操作变量的时候,JS 是如何工作的.如果你和我有同样的困惑,希望这篇文章能给你一些启发. 译文,喜欢原文的可以直接拉到底部 当我们声明变量.初始化变量.更改变量值的时候,到底会发生什么?JavaScript 是如何实现这些基本的功能?最重要的是,我们如何才能理解这些基础知识? 本文将覆盖以下 4 个方面: JavaScript 原始数据类型的变量声明和

[iOS通过逆向理解Block的内存模型][iOS_Block]

前言 正常情况下,通过分析界面以及 class-dump 出来头文件就能对某个功能的实现猜个八九不离十.但是 Block 这种特殊的类型在头文件中是看不出它的声明的,一些有 Block 回调的方法名 dump 出来是类似这样的: - (void)FM\_GetSubscribeList:(long long)arg1 pageSize:(long long)arg2 callBack:(CDUnknownBlockType)arg3; 因为这种回调看不到它的方法签名,我们无法知道这个 Block

[Java8内存模型PermGen Metaspace实例解析][Java8_PermGen Metaspace]

一.JVM 内存模型 根据 JVM 规范,JVM 内存共分为虚拟机栈.堆.方法区.程序计数器.本地方法栈五个部分. 1.虚拟机栈:每个线程有一个私有的栈,随着线程的创建而创建.栈里面存着的是一种叫"栈帧"的东西,每个方法会创建一个栈帧,栈帧中存放了局部变量表(基本数据类型和对象引用).操作数栈.方法出口等信息.栈的大小可以固定也可以动态扩展.当栈调用深度大于JVM所允许的范围,会抛出StackOverflowError的错误,不过这个深度范围不是一个恒定的值,我们通过下面这段程序可以测

[详解C语言中的内存四区模型及结构体对内存的使用][C]

内存四区 1.代码区 代码区code,程序被操作系统加载到内存的时候,所有的可执行代码都加载到代码区,也叫代码段,这块内存是不可以在运行期间修改的. 2.静态区 所有的全局变量以及程序中的静态变量都存储到静态区. 3.栈区 栈stack是一种先进后出的内存结构,所有的自动变量,函数的形参都是由编译器自动放出栈中,当一个自动变量超出其作用域时,自动从栈中弹出.对于自动变量,什么时候入栈,什么时候出栈,是不需要程序控制的,由C语言编译器.实现栈不会很大,一般都是以K为单位的. 当栈空间以满,但还往栈

[详解Java语言中一个字符占几个字节？][Java]

题主要区分清楚内码(internal encoding)和外码(external encoding)就好了. 内码是程序内部使用的字符编码,特别是某种语言实现其char或String类型在内存里用的内部编码: 外码是程序与外部交互时外部使用的字符编码.“外部"相对"内部"而言:不是char或String在内存里用的内部编码的地方都可以认为是"外部”.例如,外部可以是序列化之后的char或String,或者外部的文件.命令行参数之类的. Java语

[详解易语言中的数据类型][Link 1]

各种数据存放在磁盘或内存中都有其不同的存放格式,因此就存在不同的数据类型.了解各种数据的特性,对编程开发来说是十分重要. 程序中经常会进行一些运算,易语言中的运算都要使用运算符进行识别处理,并通过运算表达式来完成运算操作.程序中对各数据之间的关系的描述也要通过运算符. 1.易语言的数据类型 一个程序内部应包括两个方面的内容:1.数据的描述.2.操作步骤,即对程序动作的描述. 数据是程序操作的对象,操作的结果会改变数据的内容.打个比方:要做一道菜,做菜前先选择烹饪的原材料(即对数据进行描述),然后

[详解Swift语言中的类与结构体][Swift]

![image][]

类 在 Swift 中类是建立灵活的构建块.类似于常量,变量和函数,用户可以定义的类的属性和方法.Swift给我们提供了声明类,而无需用户创建接口和实现文件的功能.Swift 允许我们创建类作为单个文件和外部接口,将默认在类一次初始化来创建. 使用类的好处: 继承获得一个类的属性到其他类 类型转换使用户能够在运行时检查类的类型 初始化器需要处理释放内存资源 引用计数允许类实例有一个以上的参考 类和结构的共同特征: 属性被定义为存储值 下标被定义为提供访问值 方法被初始化来改善功能 初始状态是由初

[详解C语言中的函数、数组与指针][C 1]

1.函数:当程序很小的时候,我们可以使用一个main函数就能搞定,但当程序变大的时候,就超出了人的大脑承受范围,逻辑不清了,这时候就需要把一个大程序分成许多小的模块来组织,于是就出现了函数概念:   函数是C语言代码的基本组成部分,它是一个小的模块,整个程序由很多个功能独立的模块(函数)组成.这就是程序设计的基本分化方法: (1) 写一个函数的关键: 函数定义:函数的定义是这个函数的实现,函数定义中包含了函数体,函数体中的代码段决定了这个函数的功能: 函数声明:函数声明也称函数原型声明,函数的原

[详解C语言中结构体的自引用和相互引用][C 2]

结构体的自引用(self reference),就是在结构体内部,包含指向自身类型结构体的指针. 结构体的相互引用(mutual reference),就是说在多个结构体中,都包含指向其他结构体的指针. 1. 自引用 结构体 1.1 不使用typedef时 错误的方式: struct tag\_1\{ struct tag\_1 A; /\* 结构体 \*/ int value; \}; 这种声明是错误的,因为这种声明实际上是一个无限循环,成员b是一个结构体,b的内部还会有成员是结构体,依次下去,无线循环.

[详解c语言中的 strcpy和strncpy字符串函数使用][c_ strcpy_strncpy]

strcpy 和strcnpy函数–字符串复制函数. 1.strcpy函数 函数原型:char \*strcpy(char \*dst,char const \*src)            必须保证dst字符的空间足以保存src字符,否则多余的字符仍然被复制,覆盖原先存储在数组后面的内存空间的数值,strcpy无法判断这个问题因为他无法判断字符数组的长度. \#include <stdio.h> \#include<string.h> int main() \{ char message

[详解Go 语言中的比较操作符][Go]

这篇文章专注于 6 个操作符,==,!=,<,<=,> 和 >=.我们将深入探讨它们的语法和用法的细微差别.对很多人来说,这听起来不像是吸引人的事,或者他们可能已经从其他编程语言获得了糟糕的经验.然而,在 Go 中它们定义的很好并简洁.下面讨论的主题,如可比性将出现在其他场合,如 maps.为了使用上述操作符,至少有一个操作数需要可赋值给第二个操作数: package main import “fmt” type T struct \{ name string \}

[详解C语言中的指针与数组的定义与使用][C 3]

指针的特点 他就是内存中的一个地址 指针本身运算 指针所指向的内容是可以操作的 操作系统是如何管理内存的 栈空间 4M~8m的大小 当进入函数的时候会进行压栈数据 堆空间 4g的大小 1g是操作系统 全局变量 内存映射 可以对内存的内容修改修改硬盘的内容 一般在数据库中经常使用 内存的分配与释放 c语言分配内存的方法 // malloc(需要分配的大小): 这里的分配的大小需要对齐的2的指数 void \*mem = malloc(size); 释放内存 // 一般分配的内容都是在堆空间中的 //

[详解C语言中的符号常量、变量与算术表达式][C 4]

C语言中的符号常量 在结束讨论温度转换程序前,我们再来看一下符号常量.在程序中使用 300.20 等类似的"幻数"并不是一个好习惯,它们几乎无法向以后阅读该程序的人提供什么信息,而且使程序的修改变得更加困难.处理这种幻数的一种方法是赋予它们有意义的名字.\#define 指令可以把符号名(或称为符号常量)定义为一个特定的字符串: \#define 名字 替换文本 在该定义之后,程序中出现的所有在 \#define 中定义的名字(既没有用引号引起来,也不是其它名字的一部分)都将用相应的替换文本.

[javascript]: https://www.zhangshengrong.com/p/OgN5DwJdan/
[iOS_Block]: https://www.zhangshengrong.com/p/q0ar5go1xr/
[Java8_PermGen Metaspace]: https://www.zhangshengrong.com/p/9MNlDrlpNJ/
[C]: https://www.zhangshengrong.com/p/zD1yQ6L01r/
[Java]: https://www.zhangshengrong.com/p/Mr1WylYzNG/
[Link 1]: https://www.zhangshengrong.com/p/q0arAzK1xr/
[Swift]: https://www.zhangshengrong.com/p/zD1yrvJarv/
[image]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMTg4MTc0Mi1hOGFjODdiYWEwZmYwNjBiLnBuZyF3ZWI?x-oss-process=image/format,png
[C 1]: https://www.zhangshengrong.com/p/P71MMKZ1dB/
[C 2]: https://www.zhangshengrong.com/p/pDXB0xlYaP/
[c_ strcpy_strncpy]: https://www.zhangshengrong.com/p/yOXD529q1B/
[Go]: https://www.zhangshengrong.com/p/q0arZV24ax/
[C 3]: https://www.zhangshengrong.com/p/YjNKpY9lXW/
[C 4]: https://www.zhangshengrong.com/p/wradZDWLXB/