精华内容
下载资源
问答
  • 二级指针作用详解

    2020-03-29 16:52:01
  • 主要介绍了C语言中的指针以及二级指针代码详解,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • C:一级指针与二级指针详解

    千次阅读 多人点赞 2019-10-29 15:04:43
    1.指针和数组 指针是个用来存放地址的变量; &arr表示整个数组; arr数组名表示首元素的地址;...一级指针就是指指针,里面放的就是元素的地址,我们可以通过访问元素的地址来找到该地址里存放的内...


    指针是C语言的灵魂,我想对于一级指针大家应该都很熟悉,也经常用到:比如说对于字符串的处理,函数参数的“值,结果传递”等,对于二级指针或者多级指针,我想理解起来也是比较容易的,比如二级指针就是指向指针的指针、… 、n级指针就是…

    一级指针

    一级指针就是指指针,里面放的就是元素的地址,我们可以通过访问元素的地址来找到该地址里存放的内容,即元素本身。
    比如:

    int main(){
    	char str[] = { 1, 2, 3, 4, 5, 6, 7 };
    	int i;
    	for (i = 0; i < sizeof(str) / sizeof(str[0]); i++){
    		printf("%d", *str+i);
    	}
    	system("pause");
    	return 0;
    }
    

    用途:

    通常当作函数的输入参数,因为一级指针作为函数参数,在调用的时候,实参和形参是不同的内存空间,只是,这个内存空间存放的指针指向的是同一块地址 ,所以形参在函数执行中可以访问实参指向的内存空间,但是形参的指向的改变并不能影响实参。 总结一句话“一级指针做函数参数, 在函数内做形参做重新指向并不会影响实参的指向”

    函数传参知识点:

    1. 当传入参数时,函数形参会立即申请形参的内存空间,函数执行完毕后,形参的内存空间立即释放掉。
    2. 函数参数传参本质:实参传给形参,都是拷贝

    一级指针应用需要注意的:

    1. 不要在函数中,改变形参的指向来达到改变实参指向的效果,因为形参和实参只是两个指向同一空间的不同的指针。
    2. 因为形参和实参指向的是同一空间,所以可以在形参中改变其指向空间的值,如此实参指向的空间地址也发生改变。

    代码实例:

    #include <stdio.h>
    #include <stdlib.h>
    
    void change1(int p){
    	p = 20;
    }
    
    void change2(int *p){
    	*p = 20;
    }
    
    int main(){
    	int a = 10;
    
    	change1(a);
    	printf("%d\n", a);
    	change2(&a);
    	printf("%d\n", a);
    
    	system("pause");
    	return 0;
    }
    

    代码生成图:
    在这里插入图片描述
    为什么change1没有修改,而change2修改了呢?

    change(a)传参时,p 申请内存空间,这时有两个内存空间,a的内存空间内容10拷贝形参value,这时value内存空间的内容为10,p = 20,修改了p 内存空间的内容,a内存空间的内容仍然是10,所以未修改。

    change(&a)传参时,指针变量p申请内存空间,这时有两个内存空间,a的地址拷贝给形参p,p的内存空间存放的是a的地址,即p指向a,*p = 20,即修改p指向的内存空间——a的值。所以修改了。

    二级指针

    二级指针就是指向一级指针的指针,里面保存的是一级指针变量的内存地址

    比如:

    	int a=10;
    	int *pa=&a;
    	int **ppa=&pa;//表示a的地址存放在pa中,pa的地址存放在ppa中,pa是一级指针,ppa是二级指针.
    

    在以上 ppa指向 pa、pa指向 a的指向关系中:

    • a 是一段内容( 10 );
    • pa 是一个指针变量,其中存放着C的地址,但是pa也要占空间的啊,所以pa也有地址;
    • ppa 是一个二级指针变量,其中存放着 pa的地址, ppa也有地址

    用途:

    在函数内部定义一个指针p,在函数内给指针赋值,函数结束后对指针p生效,那么我们就需要二级指针!

    #include <stdio.h>
    #include <stdlib.h>
    
    int a = 10;
    int b = 100;
    int *q;
    
    void func(int **p){
    	printf("func:&p = %p, p= %d\n", &q, **p);
    	*p = &b;
    	printf("func:&p = %p, p= %d\n", &q, **p);
    }
    
    int main(){
    	printf("&a = %p, &b = %p, &q = %p\n", &a, &b, &q);
    	q = &a;
    	printf("*q = %d, q = %p, &q = %p\n", *q, q, &q);
    	func(&q);
    	printf("*q = %d, q = %p, &q = %p\n", *q, q, &q);
    
    	system("pause");
    	return 0;
    }
    

    代码生成图:
    在这里插入图片描述
    将指针q的地址到函数(二级指针**p),(拷贝了指针但是指针内容,也就是指针所指向的地址是不变的)所以它还是指向一级指针q(*p = q)。在这里无论拷贝多少次,它依然指向q,那么 *p = &b;自然的就是 q = &b 了。

    指针运算

    • 指针 + - 整数
    int main(){
        float values[5];
        float *vp;
        //指针+-整数;指针的关系运算
        for (vp = &values[0]; vp < &values[5];) {
            *vp++ = 0;     
        }
        return 0;
    } 
    
    • 指针 - 指针

    当2个指针指向同一个区域的时候,指针减去指针得到的是指针和指针之间元素的个数,而不是字节数。

    int main(){
        int a[5][5];
        int (*p)[4];
        p = a;
        printf("%p, %d", &p[4][2] - &a[4][2],  &p[4][2] - &a[4][2]);
        // 0xfffffffc, -4
        return 0;
    }
    
    • 指针的关系运算
    int main() {
        int arr[10] = {1,2,3,4,5};
        int* p = arr; 
        while(p <= &arr[9]){//指针比较大小 
            printf("%d ", *p);
            p++;    
        }
        // 1 2 3 4 5 0 0 0 0 0 
        return 0; 
    }
    
    

    指针习题

    1. 下列代码的运行结果是()
    	int a[] = { 1,2,3,4 }; 
    	int* b = a;
    	*b += 2; 
    	*(b + 2) = 2;
    	b++; 
    	printf(" %d, %d\n", *b, *(b + 2));
    

    A 1,3
    B 1,2
    C 2,4
    D 3,2

    标准答案:

    C

    答案解析:

    	b++

    使得指向a[0]的指针 b 指向a[1] 。(没有此语句答案是D)

    1. 以下程序的输出结果是?
    #include <stdio.h> 
    
    int main() {
    	char a[10] = { '1','2','3','4','5','6','7','8','9',0 }, * p; 
    	int i;
    	i = 8;
    	p = a + i;
    	printf("%s\n", p - 3);
    
    	return 0;
    }
    

    A 6
    B 6789
    C ‘6’
    D 789

    正确答案:

    B

    答案解析:

    p - 3 找到字符‘6’的位置,然后打印直到遇到\0

    1. 指针变量p进行自加运算(即 执行p++;)后,地址偏移值为1,则其数据类型为 char。说法是否正确?
    • 正确
    • 错误

    正确答案: 错误

    答案解析:

    C:unsigned char C++:空类、bool
    而且,指针p的数据类型应该是char*,应该错在这里

    1. int a = (int)(((int *)0) +4 ); a 等于多少?为什么?

    a = 16,0 被强转为 int *,所以 + 4 表示偏移了4个int大小的地址(一个int为4个字节),所以 a = 16;

    同理

    int a = (int)(((char *)0) +4 )
    

    a = 4

    int a = (int)(((double *)0) +4 )
    

    a = 32

    int a = (int)(((void *)0) +4 )
    

    转化为 void * 后 不能++

    在这里插入图片描述

    改正后的代码:

    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    int main() {
    	char src1[] = "hello, world";
    	char* src = src1;
    	char* dest = NULL;
    	int len = strlen(src);
    	dest = (char*)malloc(sizeof(src1));
    	if (dest != NULL) {
    		char* d = dest;
    		char* s = src + len - 1;
    		while (len-- != 0) {
    			*d++ = *s--;
    		}
    		*d = '\0';
    		printf("%s", dest);
    
    		free(dest);
    		dest = NULL;
    	}
    	return 0;
    }
    

    头文件中尖括号:编译时,将在系统包含目录中搜索头文件中的括号。如果找不到,则会在源代码所在的目录中对其进行搜索。

    头文件中双引号:编译时,将在源代码所在的目录中搜索头文件中的双引号,如果未找到,将在系统包含目录中搜索该头文件中的双引号。

    1. 若二维数组a有m行n列,则下面能够正确引用元素 a[i][j] 的为() 。

    A. * (a + j * n + i)
    B. * (a + i * n + j)
    C. * (*(a+i)+j)
    D. * (*a+i)+j

    正确答案: C、D

    答案解析:

    #include <iostream>
    using namespace std;
    
    // 此时 m = n = 3, i = j = 2, a[2][2] == 9
    int main() {
        int a[3][3] = { 1,2,3,4,5,6,7,8,9 };
        cout << *(a + 2 * 3 + 2) << endl;    // 004FFAE0
        cout << *(*a + 2) + 2 << endl;       // 5
        cout << *(*(a + 2) + 2) << endl;     // 9
        cout << *(a[2] + 2) << endl;         // 9
        return 0;
    }
    

    如有不同见解,欢迎留言讨论!

    展开全文
  • 二级指针详解

    2018-01-12 18:19:26
    二级指针: 1.定义:数组名其实就是一个指针常量,保存数组的首地址,数组名是一个指针常量,不能修改它指向的值,因此可以当做一个指针变量指向数组,这样数组名加下标可以访问数组中的元素,使用指针名加下标也...

    二级指针:

    1.定义:数组名其实就是一个指针常量,保存数组的首地址,数组名是一个指针常量,不能修改它指向的值,因此可以当做一个指针变量指向数组,这样数组名加下标可以访问数组中的元素,使用指针名加下标也可以访问数组中的元素,数组名就是指针,指针也可以当做数组名来使用。 用二级指针指向一级指针的地址,一级指针指向的是个数组,就可以用二级指针来操作数组。                                                                                                                   

    实例:          int a[5]={0,1,2,3,4};                                                                                                                                                             int *p=a;                                                                                                                                                             int **pp=&p;                                                                                                                                              

    2.实例:

    1. #include <stdio.h>  //头文件  
    2. #include <stdlib.h
    3.  
    4. int main()  
    5. {  
    6.     int i,a[10]={1,2,3,4,5,6,7,8,9,10};//声明并初始化  
    7.     int *p,**pp;  
    8.  
    9.     printf("使用数组方式输出数组各元素的值:\n");  
    10.     for(i=0;i<10;i++)   //使用数组方式输出  
    11.     {  
    12.         printf("%4d  ",a[i]);  
    13.     }  
    14.  
    15.     printf("\n使用一级指针变量输出数组各元素的值:\n");  
    16.     p=a;  
    17.     for(i=0;i<10;i++)   //使用一级指针变量输出  
    18.     {  
    19.         printf("%4d  ",*p++);  
    20.     }  
    21.  
    22.     printf("\n使用二级指针变量输出数组各元素的值:\n");  
    23.     p=a;  
    24.     pp=&p;  
    25.     for(i=0;i<10;i++)   //用二级指针变量输出  
    26.     {  
    27.         printf("%4d  ",*(*pp+i));  //pp是个二级指针,它指向一级指针p,p又指向数组的首地址,所以*pp就是p指向的值就是数组的地址,*pp+j就是数组的地址,*(*pp+j)就是数组中的值。
    28.     }  
    29.  
    30.     printf("\n使用二级指针变量**p方式输出数组各元素的值:\n");  
    31.     p=a;  
    32.     for(i=0;i<10;i++,p++)//使用二级指针变量**p方式输出  
    33.     {  
    34.        printf("%4d  ",**pp);  //*pp是p的值数组的地址,**pp就是数组的值
    35.     }  
    36.  

    37.     printf("\n");  
    38.  
    39.     system("pause");  
    40.     return 0;  
    41. 结果:
    42. iuzj@ET302Buildver:~/zhanghong/make/point$ ./a.out 
      使用数组方式输出数组各元素的值:
         1     2     3     4     5     6     7     8     9    10  
      使用一级指针变量输出数组各元素的值:
         1     2     3     4     5     6     7     8     9    10  
      使用二级指针变量输出数组各元素的值:
         1     2     3     4     5     6     7     8     9    10  
      使用二级指针变量**p方式输出数组各元素的值:
         1     2     3     4     5     6     7     8     9    10  
      sh: 1: pause: not found
      liuzj@ET302Buildver:~/zhanghong/make/point$ 

    展开全文
  • 主要介绍了C语言中二级指针的实例详解的相关资料,希望通过本文能帮助到大家,让大家掌握理解二级指针的知识,需要的朋友可以参考下
  • 本文主要介绍C语言 二级指针,这里整理了C语言中二级指针的基础资料并附有示例代码和实现结果,帮助大家学习理解相关知识,有学习的朋友可以参考下
  • C语言-一级指针与二级指针详解(图文并茂,深入浅出) 。 https://blog.csdn.net/Xminyang/article/details/81902637 一、一级指针 如下图所示,整型指针xptr指向变量x的地址。 int *xptr; int x=10; xptr =...

    C语言-一级指针与二级指针的详解(图文并茂,深入浅出)

    。 https://blog.csdn.net/Xminyang/article/details/81902637

    一、一级指针

    如下图所示,整型指针xptr指向变量x的地址。

    int *xptr;
    int x=10;
    
    xptr = &x;
    
    
    • 1
    • 2
    • 3
    • 4
    • 5

    一级指针

    源码:

    #include <stdio.h>
    int main()
    {
        int *xptr = NULL;
        int x = 10; 
    
        xptr = &x; 
    
        printf("x = %d, *xptr = %d\n", x, *xptr);
        printf("&x = %p, xptr = %p\n", &x, xptr);
    
        return 0;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    运行结果:
    运行结果1

    二、二级指针

    实现方法一

    如下图所示,先为二级整型指针ptr分配空间,然后赋值。

    int  **ptr=NULL;
    int num=4, size=4, i,j;
    
    ptr = (int **)malloc(num*sizeof(int*));
    for(i=0; i<num; ++i)
    {
    	*(ptr+i) = (int *)malloc(size*sizeof(int));
    	*(*(ptr+i) +j)=(i+1)*j;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    二级指针1

    源码:

    #include <stdio.h>
    #include <stdlib.h>                                                                                                                    
    int main()
    {
        int **ptr = NULL;
        int num=4, size=4, i, j;
        
        ptr = (int **)malloc(num * sizeof(int *));
        for(i=0; i<num; ++i)
        {   
      		*(ptr+i) = (int *)malloc(size * sizeof(int));
      		for(j=0; j<size; ++j)
      		*(*(ptr+i)+j) = (i+1)*j;
        }   
        for(i=0; i<num; ++i)
        {   
            for(j=0; j<size; ++j)
            {
            	printf("(%d, %d) -> %d\t", i, j, *(*(ptr+i)+j));
            }   
            printf("\n");
        }   
        return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    运行结果:
    运行21

    实现方法二

    如下图所示,先为二级整型指针ptr分配空间,然后赋值。
    与实现方法一的不同之处,在于使用数组形式就行相关操作。

    int  **ptr=NULL;
    int num=4, size=4, i;
    
    ptr = (int **)malloc(num*sizeof(int*));
    for(i=0; i<num; ++i)
    {
    	ptr[i]= (int *)malloc(size*sizeof(int));
    	ptr[i][j]=(i+1)*j;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    在这里插入图片描述

    源码:

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        int **ptr = NULL;
        int num=4, size=4, i, j;
    
        ptr = (int **)malloc(num * sizeof(int *));
        for(i=0; i<num; ++i)
        {
        	ptr[i] = (int *)malloc(size * sizeof(int));
        	for(j=0; j<size; ++j)
        	{
        		ptr[i][j] = (i+1)*j;
        	}
        }   
        for(i=0; i<num; ++i)
        {   
            for(j=0; j<size; ++j)
            {   
                printf("[%d, %d] -> %d\t", i, j, ptr[i][j]);                                                                
            }   
            printf("\n");
        }   
    
        return 0;
    }
    
    

    运行结果:
    运行结果22

    展开全文
  • 二级指针详解

    千次阅读 2014-03-08 19:56:15
    错误的原因是:**input是个二级指针,相当于行指针,*input[1]相当于下移了一行的位置,所以会出现访问错误。 改写成下面这样就正常了 例7: void _test(char**input) { *input = (char *)malloc(10); ...
  • 如果一个指针指向的是另外一个指针,我们就称它为二级指针,或者指向指针的指针。 假设有一个 int 类型的变量 a,p1是指向 a 的指针变量,p2 又是指向 p1 的指针变量,它们的关系如下图所示: 将这种关系转换为C语言...
  • 一级指针二级指针详解

    千次阅读 2015-08-08 23:12:38
    void  change_val( ...执行到语句[2]时,val不变,... 使用二级指针,也就是指针的指针时,其中一级指针是存放的是一个地址,二级指针存放的是一级指针的地址。也就是上面所说的p指针的值发生了变化。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,338
精华内容 11,735
关键字:

二级指针的作用详解