精华内容
下载资源
问答
  • Const指针变量只保护其Value值不被改变,并不能保护指针所指向的地址的值不被改变,下面起来学习一下
  • C语言指针指针变量

    千次阅读 多人点赞 2019-04-19 16:54:08
    概念:当定义一个变量时,系统会为这个变量分配内存,比如,int a,系统会给变量a分配一块内存,大小为in型的4个字节,而且每个字节都会有一个编号,这个编号就是地址,这个编号是计算机抽象出来用于访问数据的,...

    一、指针

    概念:当定义一个变量时,系统会为这个变量分配内存,比如,int a,系统会给变量a分配一块内存,大小为in型的4个字节,而且每个字节都会有一个编号,这个编号就是地址,这个编号是计算机抽象出来用于访问数据的,实际上为一个数字。当计算机需要访问数据时,会先找到它的地址,再来获取改地址里的数据。比如,int a=1;当计算机需要printf("%d",a)时,它会先找到a的地址(比如0x000001),然后找到a的值为1。而一个变量的地址就称为该变量的指针。指针就是一个地址,它在计算机中是一个内存单元的编号,一个十六进制数。

    二、指针变量:c语言有很多种变量,每种变量都会储存一种数据,而指针变量就是专门来储存指针的变量,如定义一个指针变量p,p是一个指向int型数据的指针,即p可以存int型变量的地址。

    int *p;

    1.这里有两种访问数据的方式:

    1. 直接访问:就像上面所说,计算机先找到该变量的地址,再找到该变量的值
    2. 间接访问:与第一种不同,这里要用到两个变量,用一个变量2来储存变量1的地址,然后通过变量2来找到变量1的值

    在函数传参时,在函数体里只改变型参的值,对实参不会造成影响,这里通过地址的传递可以对实参造成影响

    *p1和*p2的值虽然都是2和1,但是原理不同。

    在swap2函数里,*p1是通过b的地址找到了b的值,而此时a和b的值并没有交换所以*p1是2,*p1也是这样。

    在swap1函数里,p1和p2的值(p1和p2的值是a和b的地址)没有改变,但在上面已经交换了a和b的值,所以*p1通过a的地址找到a的值为2。

    2.指针的大小:指针的大小和指针本身没有关系,这是由CPU运行模式的寻址位数决定的

    #include<stdio.h>
    #include<windows.h>
    int main()
    {
    	int a;
    	int *p1;
    	float *p2;
    	double *p3;
    	char *p4;
    	printf("sizeof(p1):%d\nsizeof(p2):%d\nsizeof(p3):%d\nsizeof(p4):%d\n",sizeof(p1),sizeof(p2),sizeof(p3),sizeof(p4));
    	system("pause");
    	return 0;
    }
    

    输出结果:

    可以看出无论是int型指针还是char型指针,大小都是4个字节。

    三、二级指针

    1.二级指针就是指针的指针,也就是说,一级指针变量用来存放变量的地址,但一级指针变量也是一个变量,它也有自己的地址,所以二级指针就是存放一级指针的地址的指针。

    展开全文
  • 对于新手来说,指针在c语言里总是一个非常难以理解的概念。这篇文章,我们将解释常量指针指针常量,const pointer to const(ps:楼主以为这可以翻译成指向常量的常量指针)的区别 常量指针 让我们先来理解...
  • 指针C语言中的精髓,但也是难点。我这不是我第次写关于C指针的文章了,只是因为指针对于C来说太重要,而且随着自己编程经历越多,对指针...可以帮大家正确理解C语言中的常量、变量指针指针变量之间的相互关系。
  • 本文主要讲了c语言指针变量作为函数参数传递,下面起来学习一下
  • C语言中的结构体指针

    千次阅读 多人点赞 2017-01-16 23:45:08
    结构体指针的概念概念:结构体变量的地址,指向某个结构体变量(同时也是结构体变量中一个元素的地址),我们可以通过结构体变量可以指向结构体包含的一些成员定义: struct 结构体名 *结构体指针变量名;...

    ###C语言中的结构体指针

    1. 结构体指针概念
    2. 结构体变量成员访问
    3. 结构体指针作为函数参数
    4. 结构体数组指针
      5.结构体指针数组
    5. 结构体的自引用与不完全声明

    ####结构体指针的概念
    概念:结构体变量的地址,指向某个结构体变量(同时也是结构体变量中第一个元素的地址)
    结构体指针变量中的值是所指向结构体变量的地址
    我们可以通过结构体变量可以指向结构体中包含的一些成员

    定义一个结构体变量:

    	struct 结构体名 *结构体指针变量名;
    	如:struct address *addr;
    

    结构体指针变量初始化:

    结构体指针变量名 = &结构体变量;
    或者:结构体指针变量名 = &(结构体变量.第一个成员)
    

    注意:结构体指针必须要初始化以后才能够继续使用
    ####结构体变量成员的访问

    结构体指针 ->成员名;如addr->country;
    (*结构体指针).成员名;(*addr).country;//很少去进行使用,注意必须去使用(),,因为.优先级大于*
    结构体变量.成员名  stu.name
    

    注意:如果是结构体指针的话,它是可以指向自己的(引用自己)

    ####结构体指针作为函数参数
    C语言中结构体传递参数,传递的时间,和空间都是很大的,因为其在调用的时候都是拷贝调用,效率是严重降低,因此结构体作为参数传递的话,此时对于效率一块,将大大的节省,严重降低了程序的效率

    结构体指针作为函数参数传递,那么会有很大优化:(实参传向形参的只是一个地址)

    out_student(struct student *stup);
    //将结构体变量的地址传入进去
    

    ####结构体数组指针
    指向结构体数组的指针
    1:结构体指针可以指向一个结构体数组,结构体指针变量的值是整个结构体数组的首地址

    struct student  stus[] = {stu,stu2};
    struct student *stup2 = stus;
    

    2:结构体指针可以指向一个结构体数组中的变量,这时结构体指针变量的值就是该结构体数组元素的地址
    3:一个结构体指针虽然可以来访问结构体变量或结构体数组,但是不能指向结构体的成员

    ####结构体的指针数组
    结构体指针数组的使用对内存开销会大大降低

     struct student *stups [] = {stup1,&stu2};
    out_students(stups,2);
    

    ####结构体指针的自引用
    一个结构体内部包含一个指向该结构体本身的指针(必须是结构体指针)
    struct Self{
    int a;
    int b;
    struct Self *s; //必须是结构体指针,指向自身
    }

    结构体的不完整声明:
    当一个结构体中去引用另外一个结构体指针,但是另一个结构体又去引用了前一个结构体指针,这样就造成了结构体类似死锁的现象,这个时候就需要用结构体不完整声明,从而去避免这种

    struct B;
    struct A{
    	struct *B b;
    };
    struct B{
    	struct *A a;	
    };
    

    代码如下:

     struct address{
         char *country;
         char *city;
         char *street;
    };
    
    struct student{
        int xh; 
        char *name;
        int age;
        int gender;
        struct address *addr;
    };
    
    #include<stdio.h>
    #include"student2.h"
    #include<string.h>
    
    void out_student(struct student *stu);
    void out_students(struct student *stups[],int n);
    int main(void)
    {
        struct address addr1 = {"china","shanghai","beijing road"};
        struct student stu = {1,"zhangsan",10,1,&addr1};
        struct student *stup1 = &stu;
    
        struct address addr2={"jap","dongjing","hefei road"};
        struct student stu2 = {2,"lisi",11,2,&addr2};
    
        printf("student name:%s\n",stup1->name);
        printf("student street:%s\n",stup1->addr->street);
        printf("===================");
        out_student(stup1);
        out_student(&stu2);
    
        /*定义一个结构体的数据*/
        struct student  stus[] = {stu,stu2};
        struct student *stup2 = stus;
    
        int i ;
        for(i = 0 ;i < 2 ; i++)
        {
            out_student(stup2+i);
            printf("---------------------------------");
        }
    
        /*定义一个结构体指针数组*/
        struct student *stups [] = {stup1,&stu2};
        out_students(stups,2);
        return 0;
    }
    
    
    void out_student(struct student *stu)
    {
        printf("student xh:%d\n",stu->xh);
        printf("student name:%s\n",stu->name);
        printf("student gender:%d\n",stu->gender);
        printf("student age:%d",stu->age);
        printf("stduent country:%s\n",stu->addr->country);
        printf("student city:%s\n",stu->addr->city);
        printf("student street:%s\n",stu->addr->street);
        printf("*****************************");
        printf("size of:%d\n",sizeof(stu));
    }
    
    void out_students(struct student *stup[] ,int n)
    {
    	//代码省略
    }
    

    欢迎大家的访问,代码可以进行run,因为最近比较忙,所以可能质量有点小下降,后面会修正。谢谢大家的访问

    展开全文
  • C语言中指针局部变量释放问题

    千次阅读 2019-03-11 21:01:02
    C语言中指针局部变量释放问题1.问题代码2.次改动3.理论4.佐证测试代码5.总结 1.问题代码 #include &amp;amp;amp;quot;stdio.h&amp;amp;amp;quot; #include &amp;amp;amp;quot;string.h&amp;amp...


       一个朋友有次跟我探讨一段代码,其中涉及了局部变量被释放的问题,但是意外发现定义的局部指针变量在释放时候会有些奇怪的现象,借此我查找一些资料,写了测试佐证代码得出结论。不太清楚的朋友可以了解一下。


    1.问题代码

    #include "stdio.h"
    #include "string.h"
    int* get(int a ,int b)
    {
      int c = 0;
      c = a + b;
      printf("%p\n",&c);
      return &c;
    }
    
    int main(void)
    {
      int *p = get(4,5);
      printf("%p\n",p);
      return 0;
    }
    
    

    gcc 编译时警告已经显示
    在这里插入图片描述
    Waning:函数返回了一个局部变量的地址

    • 运行结果:
      在这里插入图片描述

    2.一次改动

        这里我对返回的地址用指针存放,返回这个指针地址

    #include "stdio.h"
    #include "string.h"
    int* get(int a ,int b)
    {
      int c = 0;
      c = a + b;
      int *d = &c;
      printf("%p\n",&c);
      return d;
    }
    
    int main(void)
    {
      int *p = get(4,5);
      printf("%p\n",p);
      printf("%d\n",*p);
      return 0;
    }
    
    
    
    • 运行结果:
      在这里插入图片描述
      》》》发现没有警告,而且地址相同,甚至值也对的

    但是经过测试发现,这个指针跟指向的值,其实都被回收了,只是没有人用而已,所以值才没有改变。

    3.理论

    -------------引用赵四老师:
        a) : 栈中的变量通常包括函数参数和函数里声明的临时变量。
        b) : 栈中的基本变量退出其作用域时,没有谁执行一段代码去释放/销毁/析构它所占用的内存,仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。
        c) : 而栈中的类变量退出其作用域时,会自动执行其析构函数

    4.佐证测试代码

    #include <stdio.h>
    int *global = NULL;
    int *f(int c)
    {
      int b = c;
      int *p1 = &b;
      global = &b;
      return p1;
    }
    
    int main()
    {
      int *p = f(6);
      printf("p_addr : %p\n",p);
      printf("p_num : %d\n",*p);
      printf("global_addr : %p\n",global);
      printf("global_num : %d\n",*global);
      printf("*f(7) return : %d\n",*f(7));
      printf("p_addr : %p\n",p);
      printf("p_num : %d\n",*p);
      printf("global_addr : %p\n",global);
      printf("global_num : %d\n",*global);
    }
    
    
    • 运行结果:
      ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190311205136665.png

    5.总结

        结果会发现,同一个地址,又被分配一次。

        其实就是说,再一次执行这个函数时,你上次用这个函数返回的地址跟指向的内存地址,又被分配使用了,所以那样的使用是不安全的,那个对的数据,只是遗留下来可被后续压栈操作覆盖的无用数据

        所以你访问一个被释放的局部变量,都是一个不安全的行为。返回可以返回数值,但是不能返回一个局部变量的地址

    展开全文
  • C语言】两个变量值的交换——指针

    千次阅读 多人点赞 2018-05-27 12:44:54
    将两个变量的值作为实参直接传递,子函数内部定义一个普通变量来对两个形参进行交换,并分别子函数和主函数打印。 #include <stdio.h> void Swap(int a,int b) { int tmp = a; a ...

         C语言中交换两个变量的值可以在主函数中直接实现,也可以通过子函数来实现。下面我们介绍用子函数实现的情况。

        1.将两个变量的值作为实参直接传递,在子函数内部定义一个普通变量来对两个形参进行交换,并分别在子函数和主函数中打印。

    #include <stdio.h>  
    
    void Swap(int a,int b)
    {
        int tmp = a;
        a = b;
        b = tmp;
        printf("a=%d,b=%d\n",a,b);
    }  
      
    int main()
    {
        int a = 5;
        int b = 10;
        printf("a=%d,b=%d\n",a,b);
        Swap(a,b);
        printf("a=%d,b=%d\n",a,b);
    
        return 0;
    }

          下面是程序的运行结果:

         从程序的运行结果我们可以看出,在子函数内部两个形参是交换成功了的,但是在主函数中却没有。那是为什么呢?我们进入函数内部来看下。

         下面是主函数中a和b的地址及值:

          下面是子函数中a和b的地址及值:

           可以看出主函数和子函数中a和b的地址不相同,即说明了两个函数中的变量不是同一个,仅仅是同名而已。这说明了两个形参已交换成功,但并未传递给实参,两个实参的值并未发生改变。

          2.第一种方法中两个实参并未发生改变,因为其地址并未传递给形参。接下来我们把实参的地址传递给形参,并且定义一个指针变量来对两个形参进行交换,并分别在子函数和主函数中打印。

    #include <stdio.h>  
    
    void Swap(int *p1,int *p2)
    {
        int *tmp = p1;
        p1 = p2;
        p2 = tmp;
        printf("a=%d,b=%d\n",*p1,*p2);
    }
    
    int main()
    {
        int a = 5;
        int b = 10;
        printf("a=%d,b=%d\n",a,b);
        Swap(&a,&b);
        printf("a=%d,b=%d\n",a,b);
    
        return 0;
    }  

         下面是程序的运行结果:

         可以看出结果还是同样错误。我们进行测试。

         下面是主函数中a和b的地址及值:

     

        下面是子函数中a,b,p1,p2的地址及值:

     

        下面是返回到主函数中四个变量的地址及值:

     

     

          以上测试结果可以说明主函数在给子函数传参时,传的是主函数中的两个变量的地址,但是在子函数中只是把形参p1和p2所指向的变量的地址进行交换,开始p1指向a,p2指向b,交换之后,p1指向b,p2指向a,没有实质性的将实参a,b的值交换。然后返回到主函数中,a和b依然是原来的值,没有交换。

         3.下面在子函数中将实参值进行交换。

    #include <stdio.h>  
    
    void Swap(int *p1,int *p2)  
    {  
        int *tmp;  
        *tmp = *p1;  
        *p1 = *p2;  
        *p2 = *tmp; 
        printf("a=%d,b=%d\n",*p1,*p2);  
    }  
      
    int main()  
    {  
        int a = 5;  
        int b = 10;  
        printf("a=%d,b=%d\n",a,b);  
        Swap(&a,&b);  
        printf("a=%d,b=%d\n",a,b); 
    
        return 0;  
    }

        以上方法看似没有错误,但是在运行时程序却会崩溃:

        上边显示,变量tmp正在被使用却没有被初始化。这种没有被初始化的指针称为野指针,也叫悬挂指针。野指针是没有访问权限的地址(指针)。没有访问权限,形参不能正常交换,所以程序崩溃。

        4.下面才是正确的写法。

    #include <stdio.h>  
    
    void Swap(int *p1,int *p2)  
    {  
        int tmp;  
        tmp = *p1;  
        *p1 = *p2;  
        *p2 = tmp;  
        printf("a=%d,b=%d\n",*p1,*p2);  
    }  
      
    int main()  
    {  
        int a = 5;  
        int b = 10;  
        printf("a=%d,b=%d\n",a,b);  
        Swap(&a,&b);  
        printf("a=%d,b=%d\n",a,b);  
    
        return 0;  
    }  

     

        由此可以总结出学习指针的一个重要知识点:一个函数的改变要影响另一个函数,两个条件:1.传指针;2.解引用。

     

    展开全文
  • c语言中的字符指针变量的解释

    千次阅读 2017-11-02 10:29:32
    2.在c语言中对字符串常量是按照字符数组处理的,下面我们来写一个字符数组的例子:char c[] = "abc"; char *s = c; printf("c[]的值为:%s\n",c); printf("s指向的内容为:%s\n",s); printf("s指
  • 全面解析C语言中指针变量.pdf
  • 关于C语言中返回局部指针变量

    千次阅读 2017-12-26 18:18:51
    关于C语言中函数返回局部指针变量出错。
  • 可以知道指针p不过也是一个需要开辟内存空间的变量,只不过里面存放的是另一个变量的地址。 既然是这样,那么能不能通过另一种方式来检验指针其实并不特殊呢?把上面代码 p 的定义修改一下,如下: int main() { ...
  • c语言结构体学习整理(结构体初始化,结构体指针)

    万次阅读 多人点赞 2018-11-01 20:22:12
    首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针一些小应用可以灵活使用,然而,我们实际应用,每变量进行次声明,再结合起来...
  • 本文介绍了C语言中地址指针变量的使用方法
  • C语言中运用结构体指针输出结构体变量 #include<stdio.h> struct Data{ int year; int mounth; int day; }data; int main(){ Data data={2020,11,7}; struct Data *ptr; ptr=&data; printf("%...
  • 课堂笔记2.1 函数设计基本原则2.2 指针变量和普通变量区别2.3 指针变量理解2.4 修改一个变量的值2.5 指针类型2.6 指针和数组C语言第九天课程笔记1. 内容安排2. 课堂笔记 C语言第七课程笔记 每一天的笔记包含如下...
  • 传递一个比原来指针更高一级的指针即可,然后函数使用*原来指针变量=地址值即可 2.一个基本的字符指针的修改demo #include <stdlib.h> #include <stdio.h> #include <string.h> // 改变一个...
  • C语言--指针交换两个变量

    千次阅读 2018-08-30 17:06:15
    //* 表示指针说明符:说明变量p是一个指针,只会定义变量的时候出现 int a; p = &amp;a; // &amp;符号表示取a的地址,如果a是数组p=a,表示数组的首地址 a=5; // *p = 5; *代表指针运算符,访问...
  • 那么,我们在C语言的结构体,只能通过定义函数指针的方式,用函数指针指向相应函数,以此达到调用函数的目的。 函数指针 函数类型 (*指针变量名)(形参列表);第一个括号一定不能少。 “函数类型”说明函数的返回...
  • 例35:C语言编程实现改变指针变量的值。 解题思路: 指针p的值是可以变化的,printf函数输出字符串时,从指针变量p当时所指向的元素开始,逐个输出各个字符,直到遇‘\0’为止。而数组名虽然代表地址,但是它是常量...
  • C语言中指针”和“指针变量”的区别是什么

    千次阅读 多人点赞 2018-03-09 13:26:07
    指针变量”则是存放前述“地址值”的变量,也可以表述为,“指针变量”是存放变量所占内存空间“首地址”的变量(因为一个变量通常要占用连续的多个字节空间)。比如int i=5;后有一句int *p=&i;,就把i的指针&i赋...
  • 根据右结合优先,先是*优先,所以这个cp变量一个指针,然后是const修饰*,所以这是一个常量指针。即指向常量的指针。 cp=&a; //正常语法 *cp=a; //错误语法,因为其指向的值是一个常量   指针常量: 首先它是...
  • c语言指针变量初始化 C声明,初始化和使用指针变量 (Declaring, Initializing and using a pointer variable in C) In this tutorial, we will learn how to declare, initialize and use a pointer. We will ...
  • 读懂变量在程序占用内存的大小对于程序优化具有非常大的好处,本篇文章将列出C语言中各类型变量在C语言程序占用的内存大小,希望大家读完后能有所收获。
  • c语言指针——(指针变量

    千次阅读 2017-12-14 12:52:46
    指针是学习c语言时,最让人头痛的一个难题。但是指针不仅是c语言的精髓,它还贯穿整个计算机底层存储与访问方式。 一、何为指针指针实际上就是地址,指针变量用来存放指针(地址)。 指针变量也是一种变量,...
  • // 申请了一个变量, 即内存开辟了一块内存, 存储数据  // 开辟了 8 个字节, Mac 下 指针都占 8 个字节  使用指针, 实际上应该说成使用指针变量  1> 算术运算  +1 移动几个字节?  看类型: int *
  • c语言中变量的引用传递和指针

    万次阅读 多人点赞 2017-08-02 19:25:15
    掌握了引用型变量指针,才能深入掌握面向过程的函数调用机制。...通过引用型变量指针变量可以让子函数直接改主函数变量,而不再需要为形参开辟内存。 //如果子函数主函数下面,一定要先声明
  • C语言中指针变量的用法.pdf
  • C语言指针变量实现 交换swap

    千次阅读 2020-12-19 14:06:33
    C语言指针变量实现 交换 不使用指针变量: 正确写法 t=a;//正确的 a=b; b=t; 错误写法 #include<stdio.h> int main() { void swap(int x,int y); int *point_1,*point_2; int a,b; scanf("%d%d",&a,...
  • 首先说一下写这篇文章的原因,学习实用算法课程期间,发现以前学习的指针相关知识还有偏差,所以CSDN上面找了挺多相关知识,基本弄明白了怎么回事,以下三篇文章对我帮助很大: ... ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 226,153
精华内容 90,461
关键字:

在c语言中一个变量的指针就是

c语言 订阅