精华内容
下载资源
问答
  • 本文给出两个C语言指针实现字符串的反转程序,感兴趣的朋友可以参考下。
  • c语言 指针

    2019-02-13 13:15:43
    学习c语言指针。ppt
  • C语言指针详解,通俗易懂,把指针描述的很清楚,看完基本有概念!
  • 本文主要讲了c语言指针变量作为函数参数传递,下面一起来学习一下
  • C语言指针笔记

    2016-07-07 15:50:25
    C语言指针笔记,一些常见的C语言误区解释,每个知识点都有解析,指针太强大,可能笔记并不全
  • C语言指针总结

    2016-11-29 11:05:21
    指针C语言中的难点,也是C语言中的精华所在,本文档列举了指针使用中的常见注意事项及易混淆知识点的对比,为C语言的初学者掌握指针提供了清晰的思路。
  • C语言 指针

    2017-10-10 10:04:46
    C语言指针教学,新手必看,强烈推荐学习,很基础的内容!
  • C语言指针式时钟设计

    2019-11-09 21:06:56
    使用 C语言绘图,结合三角函数实现指针式时钟的表盘的设计以及时、分、秒三个指针随时间实时刷新绘制的效果。
  • c语言指针学习笔记

    2018-01-05 16:05:53
    本文档是适合于基础学习C语言指针到深入学习的c语言指针的总结性文档,本人能力有限,如错误之处,请告知我。
  • c语言指针习题及答案

    2016-01-30 21:56:47
    c语言指针是较为重要的知识点,掌握指针你会更上一层楼。
  • c语言指针回调函数最全demo实例(简单明了一看就会)
  • 本文主要介绍C语言 指针数组,这里提供详细的资料和简单示例代码以便大家学习参考,有需要学习的小伙伴可以参考下
  • C语言指针讲解.ppt

    2019-07-13 22:52:02
    C语言编程,高级c语言编程
  • C语言指针基础

    2018-12-15 09:04:51
    C语言中的指针其实并没有那么可怕,我上传了一份C语言指针基础课件。欢迎大家下载。
  • 本篇文章是对C语言指针赋值的问题进行了详细的分析介绍,需要的朋友参考下
  • 主要介绍了C语言指针及占据内存空间的相关知识,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • C语言 指针PPT,比较详细,可以参考学习,不用担心指针学习方面,忘记的时候可以拿出来看一下。比较实用,拿出来与大家分享一下。
  • 本文主要讲了一下关于C语言指针的相关概念,希望对你的学习有所帮助。
  • C语言指针经典题目

    2012-12-11 16:58:00
    一个不错的C指针的代码集,里面有若干经典题目,并附上代码
  • c语言指针式钟表源码,用到graphics.h头文件,其中可加背景音乐
  • 使用C语言实现密码的输入,检验输入密码是否符合设置的密码规则,做出判断。设置密码后需再次输入密码进行校验,校验通过后,密码设置成功。
  • 试题四存在与试题三同样的问题,在执行char *str = (char *) malloc(100); 后未进行内存是否申请成功的判断; 另外,在free(str)后未置str为空,导致可能变成一个“野”指针
  • c语言指针开发,简单易学,用最简单的方式讲解 c语言的难点----指针课程资源
  • C语言指针知识点小结

    千次阅读 多人点赞 2020-01-10 15:40:06
      C语言指针基础知识点(一)–指针及指针变量   C语言指针基础知识点(二)–指针变量的引用   C语言指针基础知识点(三)–指针变量作为函数参数   C语言指针基础知识点(四)–通过指针引用数组   C语言指针...

    前期回顾

      C语言指针基础知识点(一)–指针及指针变量
      C语言指针基础知识点(二)–指针变量的引用
      C语言指针基础知识点(三)–指针变量作为函数参数
      C语言指针基础知识点(四)–通过指针引用数组
      C语言指针基础知识点(五)–用数组名作函数参数
      C语言指针基础知识点(六)–通过指针引用多维数组
      C语言指针基础知识点(七)–通过指针引用字符串
      C语言指针基础知识点(八)–返回指针值的函数
      C语言指针基础知识点(九)–指针数组和多重指针
      C语言指针基础知识点(十)–动态内存分配与指向它的指针变量

    指针小结

    1. 指针的含义

      指针就是地址,凡是出现"指针"的地方,都可以用"地址"代替,例如,变量的指针就是变量的地址,指针变量就是地址变量。

      要区分指针和指针变量。指针就是地址本身,例如2008是某一变量的地址,2008就是变量的指针。而指针变量是用来存放地址的变量。指针变量的值是一个地址

    2. 什么叫"指向"

      地址就意味着指向,因为通过地址能找到具有该地址的对象。对于指针变量来说,把谁的地址存放在指针变量中,就说此指针变量指向谁。但应注意:并不是任何类型数据的地址都可以存放在同一个指针变量中的,只有与指针变量的基类型相同的数据的地址才能存放在相应的指针变量中。例如:

    int a, *p;  // p是 int * 型的指针变量,基类型是 int 型 
    float b;
    p=&a;   // a 是 int 型,合法
    p=&b;  // b 是 float 型,类型不匹配
    

      既然许多数据对象(如变量、数组、字符串、函数等)都在内存中被分配存储空间,就有了地址,也就有了指针。可以定义一些指针变量,存放这些数据对象的地址,即指向这些对象。

      void * 指针是一种特殊的指针,不指向任何类型的数据,如果需要用此地址指向某类型的数据,应先对地址进行类型转换。显示或隐示的类型转换。

    3. 在对数组的操作中正确地使用指针

    一维数组名代表数组首元素的地址,如:

    int *p, a[10];
    p=a;
    

      p是指向 int 型类型的指针变量,显然,p 只能指向 a 数组中的元素,而不是指向整个数组。在进行赋值时一定要先确定赋值号两侧的类型是否相同,是否允许赋值。

    p = a;, 准确地说应该是:p 指向 a 数组的首元素,在不引起误解的情况下,有时也简称为:p指向a 数组。 同理,p 指向字符串,应理解为 p 指向字符串中的首字符

    4. 指针变量的归纳比较

    变量定义类型表示含义
    int *p[4]int *[4]定义指针数组p,它由4个指向整型数据的指针元素组成
    int (*p)[4]int (*)[4]p为指向包含4个元素的一维数组的指针变量
    int *p()int *()p为返回一个指针的函数,该指针指向整型数据
    int (*p)()int (*)()p为指向函数的指针,该函数返回一个整型值
    int **pint **p是一个指针变量,它指向一个指向整型数据的指针变量
    void *pvoid *p是一个指针变量,其基类型为 void,不指向具体的对象

    5. 指针运算

    a. 指针变量加减一个整数

      例如: p++, p- -, p+i, p-i, p+=i, p-=i 等均是指针变量加(减)一个整数。
      将该指针变量的原值和它指向的变量所占用的存储单元的字节数相加(减)

    b. 指针变量赋值

    将一个变量地址赋给一个指针变量。如:

    p=&a;         //  将变量a的地址赋值给p
    p=array;      //  将数组array首元素的地址赋给p
    p=&array[i];  // 将数组 array 第 i 个元素的地址赋给p
    p=max();      // max为已定义的函数,将max的入口地址赋给p
    pa=p2;        // p1和p2是基类型相同的指针变量,将p2的值赋给p1
    

    c. 两个指针变量可以相减

      如果两个指针变量都指向同一个数组中的元素,则两个指针变量值之差是两个指针之间的元素个数。

    d. 两个指针变量比较

    若两个指针变量指向同一个数组中的元素,则可以进行比较。指向前面的元素的指针变量"小于"指向后面元素的指针变量。如果 p1 和 p2 不指向同一数组则比较无意义。

    6. 指针变量可以有空值

    指针变量可以不指向任何变量,可以这样表示:

    p=NULL;
    

    其中,NULL是一个符号常量,代表整数0。在stdio.h头文件中对NULL进行了定义:

    # define NULL 0
    

    它使p指向地址为0的单元。系统保证使该单元不作他用。

    注意:

    1. 不应把一个整数赋给指针变量
    2. p的值为 NULL 与未对 p 赋值是两个不同的概念。
    3. 任何指针变量或地址都可以与NULL作相等或不相等的比较,例如: if (p==NULL)
    展开全文
  • C语言 指针实验报告

    2013-01-14 17:30:46
    有关指针的一道上机实验题,有源程序,可以详细了解指针的概念及相关应用
  • C语言指针用法和举例

    千次阅读 2020-08-20 09:55:29
    一,指针定义: 指针变量的取值范围取值0~4G,是一种数据类型(无符号整数,代表了内存编号)。...因为C语言采用的是值传递(内存拷贝),会随着变量字节数的增加而降低运行效率而传递变量的地址永

    一,指针定义:

    指针变量的取值范围取值0~4G,是一种数据类型(无符号整数,代表了内存编号)。它可以用来定义变量(与int、long一样),与int、long不同的它存储整数代表了内存的编号,通过这个变量可以访问对应编号的内存。

    二,指针的作用

    1、堆内存无法取名字(无法使用标识符与堆内存建立联系),必须配合指针。

    2、函数之间的参数是值传递(内存拷贝),使用指针可以优化参数的传递效率(需要对变量进行保护)。因为C语言采用的是值传递(内存拷贝),会随着变量字节数的增加而降低运行效率而传递变量的地址永远只拷贝4或8字节。

    void func(const int* p);但使用指针变量的值可能会被修改,可以配合const。  

    3、函数之间是相互独立的,有时协同配合需要共享变量(全局变量过多会造成命名冲突,不会被释放浪费内存),函数之间传递变量的地址可以达到共享变量的效果。

    三,指针的用法:

    定义:类型* 变量名_p;  

     1、指针变量与普通变量一样默认值不确定,一般初始化为NULL。

     2、指针变量的用法与普通变量不同,一般以p结尾加以区分。

     3、指针变量的类型决定了通过指针变量访问内存时访问几个字节。

     4、指针变量不能连续定义(一个*只能定义出一个指针变量):

      int* p1,p2; // p是指针,p2是int类型变量

      int *p1,*p2; // p1和p2都是指针变量

    赋值:指针变量 = 内存编号。   变量名_p = 地址;

        内存编号要能够访问,如果编号错误可能会造成段错误。void*可以与任意类型指针进行自动转换(C++中不行)。要保障地址与物理内存有对应关系(映射过),否则有段错误。

     int* p = malloc(4);

     int* p = # // 引用内存

    访问:*指针变量 //解引用----访问指针变量

     根据指针变量中存储的内存编号去访问对应的内存。如果之前赋值的内存编号有误,这个步骤会出现段错误。访问的字节由指针类型决定。     int* p = #                   *p <=> num;

    5,指针运算

    指针变量中存储的就是整数,因此为整型数据能使用的运算符指针变量基本都能使用
    ,但不是所有运算都有意义。
    指针+整数 = 指针+宽度*整数
    指针-整数 = 指针-宽度*整数 // 指针进行前后移动
    指针-指针 = (指针-指针)/宽度 // 两个指针之间相隔多少个元素
    指针 >、<、<=、>= 指针 可以判断两个谁在前谁在后。

    6,数组与指针

     .数组名就是个特殊的地址,也能当指针使用,数组名是个常量(数组名与数组第一个元素的首地址是对应关系,普通指针是指向关系)。数组名可以使用指针的解引用,而指针变量也可以使用数组的[];arr[i] <=> *(arr+i)。数组当函数的参数就脱变成了指针变量,长度丢失,安全性也变小void func(int * const arr,size_t len);

    7,指针的高级使用

    数组指针与指针数组:

    (1).数组指针(指针):专门用来指向数组的指针。
    int arr[10];
    int (*p)[10] = arr;
    int* p = &num;

    void func(int I,int J,int(*arr)[J])  //二维数组 函数传参使用数组指针
    (2).指针数组(数组):一个数组里存储的数据类型是指针。
                    把无序的离散数据,归纳到一起。
    int* arr[3]; <=> int *p1,*p2,*p3;

    (3).二级值针: 指向指针的指针
    4.函数指针: 指向函数的指针(不能解引用)


    9,const 指针

     const int * p; // 不能通过解引用去修改指针所指向的内存的数据
     (1)保护函数的参数
     (2)当指针指向的是只读数据,也应该加上const防止出现段错误。
       int const * p; // 同上

       int* const p; // 不能修改指针变量的值
     可以防止指针变量意外变成野指针

        const int* const p; // 既保存指针所指针的内存,也保护指针变量
        int const * const p; // 同上

    运行:

    *p_num=10
    请输入一个数字:1
    *p_num是1
    *ptr=10

    10,注意事项:

         空指针:
    变量指针的值等于NULL,这种指针叫空指针。
    不能对空指针解引用,一定会出现段错误。
    当操作重启时会跳转NULL地址,进行重启,因此NULL存储操作系统用于重启的数据。
    NULL在C语言中是一种错误标志,如果函数的返回值是指针类型,
    结果一旦NULL表示函数执行出错或失败。
    如何避免空指针造成的段错误?
    使用来历不明(函数的参数)的指针前先进行检查,if(NULL == p)。

        野指针:指针变量的值不确定,使用野指针不一定会出错。
    int* p; // 野指针
    使用野指针的后果:段错误。
    注意:野指针是无法分辨的,所以比空指针危害更。
    如何避免野指针造成的错误?
    所有的野指针都人制造出来的,只要人人都不制造野指针就会有野指针造成的错误。
       定义指针变量时一定要初始化。
       指针变量所指向的内存初始释放后要及时赋值为空(堆内存)。
       不返回局部变量的地址。

    四,用法举例

    1,定义指针在变量名前名加上*即可:

    int a=10;

    int *b=a;

    2,可以定义一个变量,同样可以给变量分配一个地址;程序中需要找到这个变量时,只要知道变量的地址,就可以调用变量的数值:

    int  data=200;
    int *pp;
    pp=&data;
    printf("*pp=%d\n",*pp);
    //------------------------
    int num;
    num=pp;
    printf("num=%d\n",num);

    3,定义的变量是局域网,那么我们可以给变量加上一个地址,放入城域网中,只要将数据的地址加入城域网,不需要再次将数据复制进入城域网:

    int arr[2];

    arr[0]=6;

    arr[1]=9;

    int *m,*n;

    *m=arr[0];

    *n=arr[1];

    4,定义一个变量A和一个指针B,此时变量A存放在内存1000区间,将变量A赋值给指针变量B,此时指针变量B所接收到的并不是A的数值,而是A的内存区间地址1000。

    5,结构体里面的指针

    typedef struct

    {

        float data[MTD_DATA_MAX];                       

    //结果数据(复数)设置最大内存64*2?根据“结果数据的脉冲数”与“结果数据的距离数”动态申请内存?

        int32_t doppler_index_scope[2];                 //多普勒序号    

    }mtd_param_packet_t;

    typedef struct

    {

        float data[MTD_DATA_MAX];  

        float time;                               

        int32_t index_scope[2];       

    }mtd_param_packet_t;

    int point_process( const mtd_param_pool_t  *mtd_param_pool)

    {

    结构体指针定义:mtd_param_packet_t *mtd_data_packet_sum = NULL;

    给指针赋值:mtd_data_packet_sum = (mtd_param_packet_t*)mtd_param_pool->sum_packet;

    指针定义:float *mtd_data_sum = NULL;

    给指针赋值:mtd_data_sum = (float*)mtd_data_packet_sum->data;

    }

    typedef struct
    {
        radar_pl_cfg_t          pl_cfg;                         
        radar_ps_cfg_t          ps_cfg;
        radar_exe_cfg_t         exe_cfg;
    }single_radar_param_t;
    
    
    typedef struct
    {
        uint32_t    fsad;
        uint32_t    fsbb;
    }single_wave_param_t;
    
    
    typedef struct
    {
        single_radar_param_t        *current_radar_param_set;      
        single_wave_param_t         *current_wave_param_set;    
        pl_config_t                 *pl_time_line_config;  
    }process_param_t;
        process_param下面的结构体current_radar_param_set下面的ps_cfg:
     给指针赋值(加了取地址符号&,因为 radar_ps_cfg_t    ps_cfg这里是结构体定变量定义):
     radar_ps_cfg = (radar_ps_cfg_t*)&process_param->current_radar_param_set->ps_cfg;
    给指针赋值(直接用(pl_time_line_config_t*)进行赋值,因为pl_config_t   *pl_time_line_config这里是指针定义):
        pl_time_line_config = (pl_config_t*)process_param->pl_time_line_config;

       6,指针指向函数

    int sum(int x,int y){return x+y;}  //定义一个函数
    int main()                                                 
    {
    int a=5;int b=6;
    int (*p)(int,int); //定义一个函数指针,(*p)()是函数指针的标志。
    p=sum;             
     /*指针赋值,这个值就是指向的这个函数。这个和一般指针赋值有所区别,类似于数组名相当于首地址的意思,可以不用取址符&      函数名(SUM )本身有指向函数首地址指针的意义*/
    int result=(*p)(a,b);
    printf("The result is %d\n",result);
    }

    7,常量指针与变量指针:左数右指

        const int* p; //p可变,p指向的内容不可变

       int const* p; //p可变,p指向的内容不可变

       int* const p; //p不可变,p指向的内容可变

      const int* const p;//p和p指向的内容都不可变

    8,结构体,指针区别

    struct MyStruct
    {
    int a;
    int b;
    int c;
    }
    
    MyStruct ss={20,30,40};//声明了结构对象ss,并把ss的三个成员初始化为20,30和40。
    MyStruct *ptr=&ss;//声明了一个指向结构对象 ss的指针。类型是MyStruct*,它指向的类型是MyStruct。
    int *pstr=(int*)&ss;//声明了一个指向结构对象 ss的指针。它的类型和它指向的类型和ptr是不同的。

    A,问怎样通过指针ptr来访问ss的三个成员变量?答案:

    ptr->a;

    ptr->b;

    ptr->c;

    B,问怎样通过指针pstr来访问ss的三个成员变量?答案:

    *pstr;//访问了ss的成员a。

    *(pstr+1);//访问了ss的成员 b。

    *(pstr+2)//访问了ss的成员c。

    让我们看看怎样通过指针来访问数组的各个单元:

    展开全文
  • 理解C语言指针

    千次阅读 多人点赞 2019-03-25 14:40:45
    C语言指针理解 本人在初学的时候认为c语言中指针很好理解,但身边好多同学一直在说老师讲的指针太抽象了,看不到,摸不着,非常难理解,甚至学了4年计算机,毕业了,不少同学还说不清楚指针是什么,遇到指针的问题...

    C语言指针理解

    本人在初学的时候认为c语言中指针很好理解,但身边好多同学一直在说老师讲的指针太抽象了,看不到,摸不着,非常难理解,甚至学了4年计算机,毕业了,不少同学还说不清楚指针是什么,遇到指针的问题必定出错,这里简单介绍一下。

    引言

    c语言中有很多抽象的东西,而指针就是其中一个,学好 c 语言就要学会计算机的思维:透过表面看本质。
    比如下面一行代码中 两个 ! 运算符

    int x = 0;
    int a = !!0; //看这里
    

    表面上:第2行的两个 ! 运算符抵消了,相当于没有。但这只是结论。
    本质上:对0进行了两次 ! 运算。这才是本质。

    很多同学整理错题的时候也是只整理表面上的结论,所以导致同一类型的题目一再二,二再三 出错。


    正题

    为什么说指针好理解?首先要有抽象或者说本质的概念。

    感觉这个世界里非常多相似的东西,上了十几年的学,就算学新知识,也能在已有的知识体系上找到很多的相似的东西,学习指针时,可以拿已有的概念做参照来学。

    下面我先给它一个定义,让你能想象的出它大概是什么,干嘛的。

    指针像商品的条形码,像汽车的车牌,像寝室的门号,又像人的身份证号…等等。你可以把他理解为一个标志,它并不代表实际内容,只有一个值,但我们可以根据它来找到对应的真实存在的对象。

    同样的,指针并不保存所指对象的完整信息,但是我们可以根据一个映射(map)关系,来根据指针中的值,来找到对应真正的对象。看以下丑图:
    比如我有个程序:

    int main(){
    	fun1();
    	...
    }
    void fun1(){
    	fun2();
    	...
    }
    void fun2(){
    	...
    }
    

    那他在内存中的某一时刻(正在执行fun2函数)可能是这样的:
    在这里插入图片描述
    而你定义的变量或者指针,在内存中的的栈中,具体到某个栈帧里。
    在这里插入图片描述
    可以看到栈内存的分配非常像一只只集装箱,集装箱里又装了一个个快递…
    在这里插入图片描述
    其中栈和堆只是个名字,认为划分的两个区域,为了方便程序内存管理。

    • 栈中的内存不需要手动回收
      比如 int a = 1;就不用手动 free(a) 操作
      因为他会随着所在函数的结束,整个函数占用的栈内存会自动释放掉,实际上是编写 c 语言的人帮你释放掉了。

    • 堆内存需要手动回收,比如 xxx* p = malloc(…); 相当于在堆内存中开辟了一块空间,在栈内存中新建了一个变量,把堆内存的地址的值赋值给栈内存中的变量(指针),在使用完毕后需要手动释放掉堆内存的地址,因为不过不主动释放,虽然栈中指针所占内存被自动回收了,但堆内存并没有被标记为释放,而又无法通过栈中的值找到这块堆内存,即发生内存泄漏,这块堆内存在该程序结束前将一直无法使用。

    • 指针和实际指向的对象是两个东西。

    废话解释:

    像商品的条形码     纯净的商品是不带条形码的,可以根据条形码找到对应的商品
    像汽车的车牌		  汽车生产出来也是不带车牌的,但车牌可以方便我们识别一辆车
    像寝室的门号        寝室本不需要门号就能使用,门号只是方便我们找到他
    像人的身份证号	 人在一诞生是没有身份证号的,是出生后才有
    

    回归正题
    比如我有以下代码

    int a = 0; 					// 定义一个int类型变量a
    int* point_a;				// 定义一个指向 int类型变量 的指针
    point_a = &a;				//把 变量a 的内存地址 赋值给 point_a
    
    //以下为比喻-------------
    
    Car aodi = ....;			// 有一辆奥迪车,它的颜色是...长...宽.........
    Car* carNum;				// 生产一个车牌
    carNum = &aodi;				// 把这个车牌挂到车上
    

    其中,无需纠结比喻部分合不合理,主要看 c 代码即可。

    看一下内存中是如何分配的
    在这里插入图片描述
    可以看到指针的值其实是一个内存地址值,而不是具体值。具体的值保存在变量 a 中。
    因此,当你进行以下地址计算时:

    printf("%d", &a);				// a 变量的地址, 					0x8004
    
    printf("%d", point_a);			// 变量 point_a 的值 				0x8004
    
    printf("%d", a);				// 变量 a 的值						0
    
    printf("%d", *point_a);			// 变量 point_a 值被按照int解析后的值 0
    

    c 语言中 * &的意思:

    首先:内存中的状态只能表示 0 或 1,因此获取内存中变量的值的真正含义,需要根据类型来解析

    变量前符号简介详情
    什么都不加变量的值根据变量的类型,解析变量所在内存地址中的值
    &变量地址获得变量的内存地址
    *寻址并解析寻找地址等于变量值的内存,根据变量类型解析这块内存中的值
    以上是指针知识的大概介绍(是什么)

    大概对指针有点概念后,还需要知道他存在的意义(为什么存在)和用法(怎么用

    存在意义

    主要是为了减轻程序员的负担。

    虽然 c 还是不 java,python,js 等写起来爽,几乎不需要关心内存了,但他相比于汇编语言,机器代码,有这种思想,在当时已经非常先进和高级了。

    因为如果让程序员直接管理 地址,解析地址中的 0 或 1,那不得累死?所以出现了指针这个东西,极大地方便了程序员来管理内存,在写代码时无需关心底层内存是如何分配的,可以更好的专注于功能的设计。
    题外话
    当然在现在,c 语言毕竟使用时还需要手动释放堆内存,允许直接访问内存地址,操作不当则很容易使得系统或者其他程序出错(如修改某游戏所占内存中的值,简称外挂),内存自动分配和回收的语言更加受到开发者的喜爱。


    如何使用

    以上是本质,如果只看现象不看本质,在做题时候稍微有点坑,便反应不过来。

    比如一般写代码时候 总是让某一类型的指针指向特定类型的变量,如下

    //易读写法
    int i = 0;
    int* point_i = &i;
    
    char c = ' ';
    char* point_c = &c;
    
    //实际中经常会简写为
    int i = 0, *pi = &i;
    char c = ' ', pc = &c;
    

    其实以上都是非常规范的写法,是指针的最简单的使用,大部分出现在入门阶段。

    深入分析

    我们通过现象看本质知道。
    析地址符 * 可以按照后面变量的类型来进行解析内存等于其后变量值的内容
    假设可以以下操作

    char c = 'a';
    
    char* point_c = &c;
    short* point_s = &c;
    int*  point_i = &c;
    

    那我们就知道这三个指针变量 的值相同,类型不同,因类型不同,解析出来的表现也不同。
    ‘a’ 在内存中存的内容实际是其 ascll 码值,即 61 ,char 类型占用的内存为 1 字节即 8 位,则在内存中形式为 000111101,
    那么 *point_c 的流程:

    1. 根据 point_c 的值获得内存地址
    2. 根据 1 得到的内存地址找到对应的内存
    3. 获取找到内存的类型
    4. 检查是否为自身或为(point_c ) 类型的子类,如果不是继续判断能否进行强制类型转换
    5. 如果是,根据所得的地址,按照自身 (point_c) 类型,获取该区域内存的值(char类型,读取1个字节),000111101
    6. 按照 自身 (point_c) 类型解析(转换为 ascll 码所代表的 字符) ,转换成 ‘a’
    *point_s 的过程与上类似,我们这里做个假设第 4 步通过了,会发生什么?

    直接来到第 5. 步:
    5. 按照自身类型(point_s),从该区域读,连续读 2 个字节 000111101 xxxxxxxx
    6. 按照 short 类型解析,大部分计算机内存中内存存储会按照高位在前,低位在后存储,因此:
    - 其读到的数据用二进制表示为 xxxxxxxx 000111101
    - 把它认为成一个 short 类型数据读取

    其他情况本质上都是这样的

    提示

    初学者最重要的就是要理解 指针它所指变量个变量。


    本篇仅面向初学者,只介绍了指针的读取,有不理解的地方欢迎留言。

    展开全文
  • 主要介绍了Swift与C语言指针结合使用实例,本文讲解了用以输入/输出的参数指针、作为数组使用的参数指针、用作字符串参数的指针、指针参数转换的安全性等内容,需要的朋友可以参考下
  • c语言指针的大小

    千次阅读 2020-02-23 13:04:27
    在不同的系统中,C语言指针的大小是不同的。 在32位系统(即x86)中,指针的大小为4字节。 在64位系统(即x64)中,指针的大小为8字节。 想要输出变量或指针的大小,我们可以采用printf("%d",sizeof()) 语句。 下面...

    在不同的系统中,C语言指针的大小是不同的。
    在32位系统(即x86)中,指针的大小为4字节。
    在64位系统(即x64)中,指针的大小为8字节。
    想要输出变量或指针的大小,我们可以采用printf("%d",sizeof())
    语句。
    下面分享一个实例
    printf("%d",sizeof(char))//1 字节 char的大小
    相信大家对这个并不陌生,无论系统如何,char型变量的大小为一字节。但如果我们稍加改动,结果就大不相同:
    printf("%d",sizeof(char*))
    那么它的输出结果是什么呢?这里输出的是指针的大小, 在32位编译器中,指针大小均为4字节;所以如果使用32位编译器,输出结果为4.同理使用64位编译器,输出结果为8.

    展开全文
  • C语言指针作为参数的传递问题

    千次阅读 2021-06-30 14:28:36
    参数传递 C语言参数传递一般分为:值传递和地址传递(本质上只有值传递) ...单纯的理解值传递和地址传递还是很简单的,但是只要一带上指针,就有点绕晕了 博主现在也是备战考研期间,复习C语言,所以深

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382,172
精华内容 152,868
关键字:

c语言指针

c语言 订阅