二级指针的3种内存模型

最新推荐文章于 2024-07-23 19:20:16 发布
最新推荐文章于 2024-07-23 19:20:16 发布
阅读量1.1k 收藏 6
点赞数 3
分类专栏： C语言提高
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbs375/article/details/52537521
版权
1.二级指针第一种内存模型 

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

int sort_arr(char**myArr,int num)
{
	char*temp;
	char **p = myArr;
	int i,j;

	for (i=0;i<num;i++)
	{
		for (j=i+1;j<num;j++)
		{
			if (strcmp(p[i],p[j])>0)
			{
				temp = p[i];//主意我们交换的只是指针的值，改变指针的指向
				p[i] = p[j];
				p[j] = temp;
			}
		}
	}
	return 0;
}
int print_arr(char**myArr,int num)
{
	int i = 0;

	for (i=0;i<num;i++)
	{
		printf("num:%s\n",*(myArr+i));
	}
	return 0;
}
int main()
{
	//数组 数组中的每一个元素是指针，指针数组
	//1.排序 2.指针做函数参数 3.内存
	int num,i,j;
	char*temp;
	char* myArr[4]={"ddd","cccc","bbbb","aaaaaaa"};
	print_arr(myArr,4);
	sort_arr(myArr,4);
	printf("----------\n");
	print_arr(myArr,4);
	system("pause");
	return 0;
}

2.二级指针第二种内存模型

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


int sort_arr(char myArr[10][20],int num)
{
	char temBuf[20];
	//char **p = myArr;
	int i,j;

	for (i=0;i<num;i++)
	{
		for (j=i+1;j<num;j++)
		{
			if (strcmp(myArr[i],myArr[j])>0)
			{
				strcpy(temBuf , myArr[i]);//把数据交换 内存块
				strcpy(myArr[i] , myArr[j]);
				strcpy(myArr[j] , temBuf);
			}
		}
	}
	return 0;
}
/*
//第一种内存模型打印函数不适用第二种内存模型
//原因:二级指针做输入_第一种内存模型 myArr + 1 与第二种内存模型 myArr + 1 
//指针步长不一样哈 指针所指向内存空间的数据不一样
int print_arr(char**myArr,int num)
{
	int i = 0;

	for (i=0;i<num;i++)
	{
		printf("num:%s\n",*(myArr+i));
	}
	return 0;
}*/

int print_arr(char myArr[10][20],int num)
{
	int i = 0;

	for (i=0;i<num;i++)
	{
		printf("num:%s\n",*(myArr+i));
	}
	return 0;
}

int main()
{
	//数组 数组中的每一个元素是指针，指针数组
	//1.排序 2.指针做函数参数 3.内存
	char temBuf[30];
	char myArr[10][20]={"ff","bbbbb","ddddd","ccccc","eeeee"};
	int num = 5;
	print_arr(myArr,num);
	
	sort_arr(myArr,num);

	printf("---------\n");
	print_arr(myArr,num);

	system("pause");
	return 0;
}

3.二级指针第三种内存模型

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

//在堆上分配内存空间 通过return返回
char** getMen(int num)
{
    char **p = NULL;
    int i,j;
    p = (char **)malloc(sizeof(char*)*num);

    for (i =0;i<num;i++)
    {
        p[i] = (char*)malloc(sizeof(char)*100);
        sprintf(p[i],"%d%d%d",9-i,9-i,9-i);//向内存空间写入数据
    }
    return p;
}

//在堆上分配内存空间，通过函数参数返回
int getMen2(char ***p,int num)
{
    char **tmp = NULL;
    int i,j;
    tmp = (char **)malloc(sizeof(char*)*num);
    if (p==NULL)
    {
        return -1;
    }
    for (i =0;i<num;i++)
    {
        tmp[i] = (char*)malloc(sizeof(char)*100);
        sprintf(tmp[i],"%d%d%d",9-i,9-i,9-i);//向内存空间写入数据
    }
    *p = tmp;//  int a ; int *p ; p = &a;   *p=10  ;通过三级指针修改二级指针的值
    return 0;
}
//释放内存空间
int freeMen(char**p,int num)
{
    int ret =0,i;
    for (i =0;i<num;i++)
    {
        if (p[i]!=NULL)
        {
            free(p[i]);
            p[i]=NULL;
        }
    }
    if (p!=NULL)
    {
        free(p);
        p=NULL;
    }
    return ret;
}
//打印
int print_arr(char**myArr,int num)
{
    int i = 0;

    for (i=0;i<num;i++)
    {
        printf("num:%s\n",*(myArr+i));
    }
    return 0;
}
//排序 只交换指针
int sort_arr(char**myArr,int num)
{
    char*temp;
    char **p = myArr;
    int i,j;

    for (i=0;i<num;i++)
    {
        for (j=i+1;j<num;j++)
        {
            if (strcmp(p[i],p[j])>0)
            {
                temp = p[i];//主意我们交换的只是指针的值，改变指针的指向
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
    return 0;
}
//排序2 交换数据
int sort_arr2(char**myArr,int num)
{
    char temBuf[20];
    char **p = myArr;
    int i,j;

    for (i=0;i<num;i++)
    {
        for (j=i+1;j<num;j++)
        {
            if (strcmp(p[i],p[j])>0)
            {
                strcpy(temBuf,p[i]);//交换数据
                strcpy(p[i] , p[j]);
                strcpy(p[j] , temBuf);
            }
        }
    }
    return 0;
}
int main()
{
    //1.排序 2.指针做函数参数 3.内存
    char **p = NULL;

    //p = getMen(5);
    getMen2(&p,5);

    //排序前打印
    print_arr(p,5);
    //排序
    sort_arr2(p,5);
    //排序后打印
    print_arr(p,5);
    //释放内存
    freeMen(p,5);
    p=NULL;
    system("pause");
    return 0;
}

4.二级指针三种内存模型图：

5.二级指针强化练习（两个辅助指针变量挖字符串）

1)使用第二种内存模型 主调函数分配内存

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include <ctype.h>
/*函数功能 根据字符c来分割字符串str*/
int splitStr(const char *str,char c ,char buf[10][20],int *num)
{
	char* p = NULL,*pTmp = NULL;//两个辅助指针变量
	int tmpcount = 0,len;
	p = str;
	pTmp = str;
	do 
	{
		p = strchr(p,c);
		
		if (p!=NULL)
		{
			if (p-pTmp>0)
			{
				strncpy(buf[tmpcount],pTmp,p-pTmp);
				buf[tmpcount][p-pTmp] = '\0';
				//printf("%s\n",buf[tmpcount]);
				tmpcount++;
				pTmp = p = p+1;
				len = strlen(p);//用来保存最后一个字符串的长度
			}	
		}
		else
		{
			//拷贝最后一个分割的字符串包括\0
			strncpy(buf[tmpcount],pTmp,len+1);
			break;
		}
		
	} while (*p!='\0');
	*num=tmpcount+1;
	return 0;
}
/*函数功能 打印二维数组*/

void printArr(char a[10][20],int n)
{
	int i;
	for (i=0;i<n;i++)
	{
		printf("%s\n",*(a+i));
	}
}

int main()
{
	char *input="abcdefg,hjkln,sssss,kkk,hhh,j";
	char ctemp = ',';
	char myArr[10][20]={0};
	char *tmp;
	
	int ret;
	int n,i;
	
	ret = splitStr(input,ctemp,myArr,&n);
	if (ret!=0)
	{
		printf("error\n");
	}
	printArr(myArr,n);
	
	system("pause");
	return 0;
}

2)使用第三种内存模型 主调函数分配内存

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

/*第三种内存模型*/
int splitStr(const char *str,char c,char **buf,int *count)
{

	char* p = NULL,*pTmp = NULL;//两个辅助指针变量
	int tmpcount = 0,len;
	p = str;
	pTmp = str;
	do 
	{
		p = strchr(p,c);

		if (p!=NULL)
		{
			if (p-pTmp>0)
			{
				strncpy(buf[tmpcount],pTmp,p-pTmp);
				buf[tmpcount][p-pTmp] = '\0';
				//printf("%s\n",buf[tmpcount]);
				tmpcount++;
				pTmp = p = p+1;
				len = strlen(p);//用来保存最后一个字符串的长度
			}	
		}
		else
		{
			//拷贝最后一个分割的字符串包括\0
			strncpy(buf[tmpcount],pTmp,len+1);
			break;
		}	
	} while (*p!='\0');
	*count=tmpcount+1;
	return 0;
}

int main()
{
	char *input="abcdefg,hjkln,sssss,kkk,hhh,j";
	char ctemp = ',';
	char **p = NULL;
	int ret;
	int n,i;
	p=(char**)malloc(10*sizeof(char*));
	if (p==NULL)
	{
		return;
	}
	for (i=0;i<10;i++)
	{
		p[i] = (char *)malloc(20*sizeof(char));
	}
	ret = splitStr(input,ctemp,p,&n);
	if (ret!=0)
	{
		printf("error\n");
	}
	for (i=0;i<n;i++)
	{
		printf("%s\n",*(p+i));
	}
         //释放内存
	system("pause");
	return 0;
}

3）使用第三种内存模型 被调函数分配内存 通过return返回

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include <ctype.h>
/*第三种内存模型 被调函数分配内存 通过return返回*/
char** splitStr2(char *str,char c,int *count)
{
	char* p = NULL,*pTmp = NULL;//两个辅助指针变量
	int tmpcount = 0,len,len2;
	char**buf;
	p = str;
	pTmp = str;
	
	//第一遍扫描 开辟第一维空间
	do 
	{
		p = strchr(p,c);
		if (p!=NULL)
		{
			if (p-pTmp>0)
			{	
				tmpcount++;
				pTmp = p = p+1;
			}	
		}
		else
		{
			break;
		}	
	} while (*p!='\0');
	*count=tmpcount+1;
	buf = (char**)malloc((tmpcount+1)*sizeof(char*));
	//printf("tmpcount:%d\n",tmpcount);
	if(buf==NULL)
	{
		return NULL;
	}

	//第二遍扫描 根据分割的字符串的长度，开辟第二维空间并拷贝字符串
	tmpcount = 0;
	p = str;
	pTmp = str;
	do 
	{
		p = strchr(p,c);
		if (p!=NULL)
		{
			if (p-pTmp>0)
			{	
				len = p-pTmp+1;
				buf[tmpcount] = (char*)malloc(len*sizeof(char));
				if (buf[tmpcount] == NULL)
				{
					free(buf);
					return ;
				}
				strncpy(buf[tmpcount],pTmp,p-pTmp);
				buf[tmpcount][p-pTmp] = '\0';
				tmpcount++;
				pTmp = p = p+1;
				len2 = strlen(p);//用来保存最后一个字符串的长度
			}	
		}
		else
		{
			//printf("tmpcount:%d\n",tmpcount);
			//printf("len2:%d\n",len2);
			buf[tmpcount] = (char*)malloc((len2+1)*sizeof(char));
			if (buf[tmpcount] == NULL)
			{
				free(buf);
				return ;
			}
			//拷贝最后一个分割的字符串包括\0
			strncpy(buf[tmpcount],pTmp,len2+1);
			break;
		}	
	} while (*p!='\0');
	return buf;
}

int main()
{
	char *input="abcdefg,hjkln,sssss,kkk,hhh,j";
	char ctemp = ',';
	char **p = NULL;
	int ret;
	int n,i;
	p = splitStr2(input,ctemp,&n);
	printf("n:%d\n",n);
	for (i=0;i<n;i++)
	{
		printf("%s\n",*(p+i));
	
	}
     //释放内存空间
     system("pause");
	return 0;
}

4）使用第三种内存模型 被调函数分配内存 通过函数参数返回

<pre name="code" class="cpp">#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include <ctype.h>
/*第三种内存模型 被调函数分配内存 通过tmpbuf返回*/
 int splitStr3(char *str,char c,char*** tmpbuf,int *count)
{
    char* p = NULL,*pTmp = NULL;//两个辅助指针变量
    int tmpcount = 0,len,len2;
    char**buf;
    p = str;
    pTmp = str;

    //第一遍扫描 开辟第一维空间
    do 
    {
        p = strchr(p,c);
        if (p!=NULL)
        {
            if (p-pTmp>0)
            {    
                tmpcount++;
                pTmp = p = p+1;
            }    
        }
        else
        {
            break;
        }    
    } while (*p!='\0');
    *count=tmpcount+1;
    buf = (char**)malloc((tmpcount+1)*sizeof(char*));
    //printf("tmpcount:%d\n",tmpcount);
    if(buf==NULL)
    {
        return -1;
    }

    //第二遍扫描 根据分割的字符串的长度，开辟第二维空间并拷贝字符串
    tmpcount = 0;
    p = str;
    pTmp = str;
    do 
    {
        p = strchr(p,c);
        if (p!=NULL)
        {
            if (p-pTmp>0)
            {    
                len = p-pTmp+1;
                buf[tmpcount] = (char*)malloc(len*sizeof(char));
                if (buf[tmpcount] == NULL)
                {
                    free(buf);
                    return -2;
                }
                strncpy(buf[tmpcount],pTmp,p-pTmp);
                buf[tmpcount][p-pTmp] = '\0';
                tmpcount++;
                pTmp = p = p+1;
                len2 = strlen(p);//用来保存最后一个字符串的长度
            }    
        }
        else
        {
            //printf("tmpcount:%d\n",tmpcount);
            //printf("len2:%d\n",len2);
            buf[tmpcount] = (char*)malloc((len2+1)*sizeof(char));
            if (buf[tmpcount] == NULL)
            {
                free(buf);
                return -2;
            }
            //拷贝最后一个分割的字符串包括\0
            strncpy(buf[tmpcount],pTmp,len2+1);
            break;
        }    
    } while (*p!='\0');
    *tmpbuf = buf;
    return 0;
}
 //释放内存空间
 void freeMem(char**p,int count)
 {
     int i =0;
     if (p == NULL)
     {
         return ;
     }
     for (i=0;i<count;i++)
     {
         if (p[i]!=NULL)
         {
             free(p[i]);
         }
     }
     if (p!=NULL)
     {
         free(p);
     }
 }
int main()
{
    char *input="abcdefg,hjkln,sssss,kkk,hhh,j";
    char ctemp = ',';
    char **p = NULL;
    int ret;
    int n,i;
    ret = splitStr3(input,ctemp,&p,&n);
    if (ret!= 0)
    {
        printf("error");
        return -1;
    }
    //printf("n:%d\n",n);
    for (i=0;i<n;i++)
    {
        printf("%s\n",*(p+i));
    
    }
    //释放内存
    freeMem(p,n);
    system("pause");
    return 0;
}



 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  BUS375
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

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

				
			

			

				

					qq_43351159的博客
				

				

					06-09
					
					269
					
				

			

		

		

			
				
二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别
第一种内存模型char *arr[]
若有如下定义
char *arr[] = {"abc", "def", "ghi"};

这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char * []），数组的每个元素都是一个地址。
其实做为一个学习者，有一个学习的氛围跟一个交流圈子特别重要这里我推荐一个C语言C++交流群1075673198，不管你是小白还是转行人士欢迎

			
		

	



                

              
                



	

		

			

				
					
c\c++ 二级指针的三种内存模型

				
			

			

				

					Zhengzhigang_ZBL的博客
				

				

					04-05
					
					893
					
				

			

		

		

			
				
1、第一种 二级指针做输入内存模型

代码如下：


​
//打印
void PrintArray(char** parr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("parr[%d]=%s\n",i,parr[i]);
	}
	return;
}

//排序
void SortArray(char** parr,int len)
{
	for (int i=0;i<len-1;i++)
	{
		for(int j=i+1;j<len;

			
		

	



                


  
              

                


	

		

			

				
					
二级指针内存四区图

				
			

			

				

					03-08
				

			

		

		

			
				
二级指针内存四区图

			
		

	





	

		

			

				
					
二级指针的三种内存模型

				
			

			

				

					dai_wen的博客
				

				

					01-28
					
					335
					
				

			

		

		

			
				
一、二级指针的第一种内存模型

《1》内存模型图： 
 
《2》程序实现：

#include
#include
#include

int Printarr(char** arraystr，int Numi)
{
    int i=0;
    for(i=0;i<Numi;i++)
    {
        printf("array为：%s\n",arraystr[i]);
    }

			
		

	



		

			
		



	

		

			

				
					
二级指针的解析

					
最新发布

				
			

			

				

					m0_74812801的博客
				

				

					07-23
					
					575
					
				

			

		

		

			
				
二级指针首先要清楚指针类型的数据是地址（p是普通变量的地址）,而二级指针指向的是指针变量的地址（换句话来说，就是取得内容是指针变量的内容也就是地址）

			
		

	





	

		

			

				
					
【C语言提高27】二级指针三种内存模型总述

				
			

			

				

					坚持！！
				

				

					12-06
					
					392
					
				

			

		

		

			
				
//二级指针三种内存模型
void main51()
{
	int i = 0;

	//01指针数组
	char* p1[] = {"123","456","789"};

	//02二维数组
	char p2[3][4] = { "123", "456", "789" };

        //03手工二维内存
	char **p3 = (char**)malloc(sizeof(char*

			
		

	





	

		

			

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

				
			

			

				

					weixin_33902301的博客
				

				

					05-19
					
					1622
					
				

			

		

		

			
				
二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别第一种内存模型char *arr[]若有如下定义char *arr[] = {"abc", "def", "ghi"};这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组(char * [])，数组的每个元素都是一个地址。在使用的时候，若要使用中间量操作元素，那...

			
		

	





	

		

			

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

				
			

			

				

					yx5666的博客
				

				

					12-03
					
					433
					
				

			

		

		

			
				
二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别第一种内存模型char *arr[]若有如下定义：


这种模型为二级指针的第一种内存模型，在理解的时候应该这样理解：定义了一个指针数组（char * []），数组的每个元素都是一个地址。在使用的时候，若要使用中间量操作元素，那么此时中间量应该定义为


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


第二种内存模型char arr[][]若有如下定义


这种模型为二级指针的第二种内存模型，在理解的时

			
		

	





	

		

			

				
					
二级指针内存模型.zip

				
			

			

				

					11-20
				

			

		

		

			
				
本项目通过"二级指针内存模型.zip"压缩包，提供了一个简单的内存模型示例，帮助开发者深入理解二级指针如何在堆区管理内存，以及如何封装内存分配、释放、排序和打印等相关操作。  首先，我们要明白什么是二级指针。...

			
		

	





	

		

			

				
					
二级指针三种内存模型强化训练

				
			

			

				

					bbs375的博客
				

				

					09-18
					
					468
					
				

			

		

		

			
				
#define _CRT_SECURRE_NO_WARNINGS
#include
#include
#include 

/*功能：把myp1,myp2指向的数据拷贝到myp3，并且排序*/
int sort(char**myp1,int num1,char(*myp2)[30],int num2,char***myp3,int *num3)
{
	char** p3 =NULL;
	int i

			
		

	





	

		

			

				
					
二级指针的内存模型

				
			

			

				

					Long_像风一样自由
				

				

					06-30
					
					264
					
				

			

		

		

			
				
指针：指向一定内存空间，其值得大小等于该空间的地址的一类特殊的变量，系统会为这个指针在临时区开辟固定大小的内存。

二级指针可以看成是存放一级指针变量的地址的变量，二级指针有三种内存模型，以字符型二级指针为例，char *pointer[30]为第一种内存模型，编译器会自动将[]退化为指针，其实质是char **pointer，其用法是char *pointer[30]={"hello","w

			
		

	





	

		

			

				
					
二级指针三种内存模型训练

				
			

			

				

					汤小萌的博客
				

				

					08-10
					
					417
					
				

			

		

		

			
				
二级指针三种内存模型综合训练

			
		

	





	

		

			

				
					
二级指针

				
			

			

				

					dianyi2646的博客
				

				

					09-02
					
					218
					
				

			

		

		

			
				
voidchange_val(char*p)
{
charnew_val[3]={2,3,4};//[2]
p=new_val; //[3]
return;//[4]
}
charval[3]={1,2,3};
char*p=val;...

			
		

	





	

		

			

				
					
二级指针三种内存模型

				
			

			

				

					saizo123的博客
				

				

					08-13
					
					1659
					
				

			

		

		

			
				
二级指针做输出模型#define  _CRT_SECURE_NO_WARNINGS 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
//指针做输出：被调用函数分配内存  -----OK
//指针做输入：主调用函数 分配内存
//求文件中的两段话的长度
int getMem(char **myp1, int *mylen1, ch

			
		

	





	

		

			

				
					
深入理解C语言-二级指针三种内存模型

				
			

			

				

					cj5785
				

				

					04-02
					
					1518
					
				

			

		

		

			
				
二级指针相对于一级指针，显得更难，难在于指针和数组的混合，定义不同类型的二级指针，在使用的时候有着很大的区别
第一种内存模型char *arr[]
若有如下定义
char *arr[] = {"abc", "def", "ghi"};

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

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值