二级指针的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语言-二级指针三种内存模型

				
			

			

				

					08-19
				

			

		

		

			
				
"详解C语言-二级指针三种内存模型"  在C语言中，二级指针是一种复杂的数据结构，指的是指针的指针，它可以指向其他指针或数组。二级指针的内存模型主要有三种：char *arr[]、char arr[][]和char arr。下面详细介绍这...

			
		

	



                

              
                



	

		

			

				
					
C语言-基础语法学习-3 二级指针

				
			

			

				

					VengaZ的学习博客
				

				

					06-29
					
					6340
					
				

			

		

		

			
				
二级指针

			
		

	



                


  
              

                


	

		

			

				
					
详解C语言中的二级指针

				
			

			

				

					weixin_47712251的博客
				

				

					05-25
					
					5710
					
				

			

		

		

			
				
在C语言中，二级指针是指一个指向指针的指针，用于指向一个指针的地址。数据类型 **变量名;其中，数据类型为指针类型，变量名为二级指针变量的名称。本篇文章详细介绍了二级指针的定义、计算规则、读写操作以及取地址操作。通过掌握二级指针的使用，C语言程序员可以更加灵活地操作多级数据结构，并提高程序的执行效率和可读性。

			
		

	





	

		

			

				
					
二级指针的解析

					
最新发布

				
			

			

				

					m0_74812801的博客
				

				

					07-23
					
					609
					
				

			

		

		

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

			
		

	



		

			
		



	

		

			

				
					
C的实用笔记32——二级指针（多级指针）

				
			

			

				

					lzh201864031的博客
				

				

					03-26
					
					1666
					
				

			

		

		

			
				
但有严重缺陷我们早就探讨过指针变量类型的重要性。

			
		

	





	

		

			

				
					
什么是二级指针

				
			

			

				

					qq_44704346的博客
				

				

					01-28
					
					1753
					
				

			

		

		

			
				
C语言-二级指针

			
		

	





	

		

			

				
					
C++学习day--17 二级指针、数组指针、指针数组

				
			

			

				

					我的博客
				

				

					08-01
					
					2225
					
				

			

		

		

			
				
C++学习day--17 二级指针、数组指针、指针数组

			
		

	





	

		

			

				
					
二级指针内存模型.zip

				
			

			

				

					11-20
				

			

		

		

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

			
		

	





	

		

			

				
					
C语言指针与汇编内存地址（二）

				
			

			

				

					06-08
				

			

		

		

			
				
 - **内存模型**：了解C语言中的栈和堆内存分配，以及如何在汇编层面映射到具体的内存地址。  4. **C语言与汇编的交互**：  - **编译器的作用**：C语言源代码经过编译器转化为汇编代码，再进一步转换为机器码。  - *...

			
		

	





	

		

			

				
					
计算机二级常考的知识点.pdf

				
			

			

				

					05-07
				

			

		

		

			
				
### 计算机二级常考的知识点解析  #### 一、计算机基础知识  1. **计算机系统**：  - **硬件**：主要包括中央处理器(CPU)、内存(RAM)、硬盘(HDD/SSD)、输入输出设备(如键盘、鼠标、显示器等)。  - **软件**：分为...

			
		

	





	

		

			

				
					
C语言中的指针以及二级指针

				
			

			

				

					luciferbeing的博客
				

				

					07-14
					
					8845
					
				

			

		

		

			
				
很多初学者都对C中的指针很迷糊，希望这篇blog能帮助到大家：
1.什么是“指针”：
在执行C程序的时候，由于我们的数据是存储在内存中的。所以对于C程序本身来说，如果想找到相应被调用的数据，就要知道存储该数据的内存地址是多少，换言之，C程序通过已知的内存地址到相应的内存位置存储数据。
这里简单说一下内存管理（对于初学者来说。为了避免专业术语引发的理解问题，下面的叙述尽量避免专业定义：），对于

			
		

	





	

		

			

				
					
【指针】一级指针&二级指针知识点梳理

				
			

			

				

					qq_53830608的博客
				

				

					12-02
					
					6658
					
				

			

		

		

			
				
/此时，三个均为指针变量，等价于Int*p1,*p2,*p2;定义Fun(p)函数，在内部对p置空，调用Fun(p)，再输出printf(“%d”,*p)//此时，仅第一个为指针变量，等价于Int*p1,p2,p2;//fun函数未被执行，想要通过另一个修改其值，必须传指针，函数内部解引用（加*）*p是对a解引用，得到a格子内的值，也就是a的值，令*p=100，(6)定义指针p，将p指向b,并通过p将b的值改为20。//p指向a，*p = 30修改了a的值。//pp指向p，(pp格子内)保存p的地址。

			
		

	





	

		

			

				
					
理解二级指针的使用与应用

				
			

			

				

					weixin_47712251的博客
				

				

					05-25
					
					1367
					
				

			

		

		

			
				
在C语言中，指针是一种存储变量地址的特殊类型。一级指针即指向变量的地址，而二级指针则指向一级指针的地址。通过一级指针，我们可以访问变量的值；而通过二级指针，我们可以访问指针的指针以及所指向的变量。二级指针是C语言中的重要概念，它可以通过多级间接引用来访问变量的值和地址。了解二级指针的计算规则和操作方法，对于理解和处理复杂的数据结构、函数传参等场景都具有重要意义。通过本文的介绍和C语言示例，我们详细说明了二级指针的使用方式，包括读、写和取地址操作。在实际编程中，合理运用二级指针可以提升程序的灵活性和效率。

			
		

	





	

		

			

				
					
高级程序员的必经之路-指针（中级篇，二级指针详解）

				
			

			

				

					qq_64576354的博客
				

				

					12-21
					
					1749
					
				

			

		

		

			
				
二级指针作用其实概括起来并不难，一句话就是用来储存一级指针的地址，解引方式和一级指针相同，但是需要注意的是一层解引是得到一级指针储存的内存，二级解引才是访问一级指针所指向内存的数据，有点绕对吗？其实我们只要知道一个道理即可，任何指针，哪怕十级指针也是变量，那么变量就要遵守变量的规则，堆，栈等等，学习从来不是散乱无章的，而是系统的，希望大家可以有个系统的学习。最后，请大家思考，既然二级指针保存的是一级指针的地址，那么一级指针又是变量，那么他的地址也是整数，所以二级指针和一级指针所保存的类型相同?

			
		

	





	

		

			

				
					
C语言指针--二级指针

				
			

			

				

					恰柠的博客
				

				

					05-28
					
					5810
					
				

			

		

		

			
				
在之前学习完一级指针后，知道每一个变量都有对应的地址，那一级指针是不是也有地址，一级指针的地址如何存放？
这几个问题就是想要这一章的内容来解决。

			
		

	





	

		

			

				
					
C语言二级指针

				
			

			

				

					AnChenliang_1002的博客
				

				

					06-25
					
					2482
					
				

			

		

		

			
				
如果一个指针指向的是另外一个指针，我们就称它为二级指针，或者指向指针的指针。假设有一个 int 类型的变量 a，p1是指向 a 的指针变量，p2 又是指向 p1 的指针变量，它们的关系如下图所示：C语言二级指针（指向指针的指针）演示图。

			
		

	





	

		

			

				
					
【C语言基础入门】二级指针、一维数组与指针、二维数组与指针

				
			

			

				

					m0_62599305的博客
				

				

					11-05
					
					2267
					
				

			

		

		

			
				
在学习C语言的过程中，理解指针的概念是非常重要的。指针提供了一种直接访问内存地址的方式，使得我们可以更加灵活地管理数据和内存。在本文中，我们将介绍C语言中的二级指针、一维数组与指针，并通过通俗易懂的语言和示例代码来帮助读者理解这些概念。C语言中的指针提供了强大的工具，通过了解和灵活运用指针，我们能够更有效地操作内存，实现复杂的数据结构和算法。二级指针为多级指针的概念提供了基础，而一维数组与指针的结合则在处理数组数据时提供了便捷的方式。在实际编程中，灵活运用这些概念可以让程序更加高效、清晰。

			
		

	





	

		

			

				
					
狗都能看懂的C++二级指针/悬挂指针的原理和应用

				
			

			

				

					个人学习笔记
				

				

					04-02
					
					1280
					
				

			

		

		

			
				
C++二级指针的应用，避免悬挂指针的问题。

			
		

	





	

		

			

				
					
C语言入门系列：探秘二级指针与多级指针的奇妙世界

				
			

			

				

					epitomizelu的专栏
				

				

					06-24
					
					1042
					
				

			

		

		

			
				
二级指针，顾名思义，是指向指针的指针，即一个变量，其类型是指向指针的地址。数据类型** pointerName;这里，表示是一个指向指针的指针，它存储的是一个指针变量的地址。int* p;p = #如上，二级指针变量pp指向的是指针变量p的地址。如上图所示，发现二级指针需要跳2级才能获取普通变量内存中的值，这也是二级指针名称的来源。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值