精华内容
下载资源
问答
  • 常量指针与变量指针的区别
    千次阅读 多人点赞
    2017-10-11 14:37:32

    1.指针变量:指针值(即指针的指向)可以改变的指针,只能指向变量;
    2.指针常量:指针值(即指针的指向)不能改变的指针,只能指向变量,但可以修改指向的实体变量的值;
    3.常量指针:指向常量的指针,所以不能修改指向的实体的值,但可以修改指针的指向(即可以指向别的常量,必须是常量);
    4.常量指针常量:指向常量,指针不能改变指向的实体的值,指针值(即指针的指向)也不能改变(是2和3的结合)。

    举例子:

    const int a = 78;    //整型常量
    int b = 10;          //b和c是整型变量
    int c = 18;
    int* kp = &b;        //指针变量
    const int* ip = &a;  //常量指针
    int const* dp = &b;  //常量指针
    int* const cp = &a;  //错,定义了指针常量,但不能指向实体常量
    int* const cp = &b;  //指针常量
    const int* const icp = &c;  //常量指针常量
    //const在*前是常量指针;const在*后是指针常量(注意:没有这种定义形式 const* int d;)
    
    *kp = 90;   //对,能修改指向的实体的值
    kp = &a;    //错,只能指向实体变量
    
    *ip = 87;   //错,常量指针不能修改指向的实体的值
    ip = &c;    //对,常量指针能指向的实体能修改(即指针值)
    
    *cp = 81;   //错,指针常量能修改指向的实体的值
    cp = &b;    //错,指针常量指向的实体不能改变(即指针值)
    
    *icp = 33;  //错,常量指针常量不能修改指向的实体的值
    icp = &b;   //错,常量指针常量不能修改指向(即指针值)
    int d = *icp;   //对,可以读间访值
    更多相关内容
  • 指针常量、常量指针常量指针常量、指针变量
  • 常量指针是指–指向常量的指针,顾名思义,就是指针指向的是常量,即,它不能指向变量,它指向的内容不能被改变,不能通过指针来修改它指向的内容,但是指针自身不是常量,它自身的值可以改变,从而指向另一个常量。...
  • 明白了这两个概念后,我们现在正式进入指针常量与常量指针。 1.指针常量与常量指针的概念 指针常量就是指针本身是常量,换句话说,就是指针里面所存储的内容(内存地址)是常量,不能改变。但是,内存地址所对应的...
  • 在这篇文章中,我们将解释常量指针,指针常量,const pointer to const(ps:楼主以为这可以翻译成指向常量的常量指针)的区别 常量指针 让我们先来理解什么是常量指针常量指针是指指针指向的地址是常量。换句话说...
  • 参考链接: ...倒着读: char * const s s is a const pointer to char,翻译:s是一个常量指针(所以s的指向是固定的),指向char类型,但s的指向地址的内容是可变的 const char * s; s is
  • C/C++中常量指针与指针常量区别

    千次阅读 2020-10-06 15:56:13
    常量指针与指针常量之间的区别常量指针: int const * p; const int * p; 定义:(常指针),可理解为常量的指针,即该指针指向的是个常量,这个常量是指针的值(地址),而不是这个地址指向的值(数); 关键点...

    常量指针与指针常量之间的区别:

    常量指针:

    int const * p;
    const int * p;
    

    定义:(常指针),可理解为常量的指针,即该指针指向的是个常量,这个常量是指针的值(地址)而不是这个地址指向的值(数)

    关键点:

    1. 常量指针指向的对象不能通过这个指针来修改,但是仍然可以通过原来的声明修改;

    2. 常量指针可以被赋值为变量的地址,之所以叫常量指针,是限制了通过这个指针修改变量的值;

    3. 指针还可以指向别处,因指针本身就是变量,可以指向任意地址;

    指针常量:

    int * const p;
    

    定义:本质是一个常量,而用指针修饰它;指针常量的值是指针,这个值因为是常量,所以不能被赋值;

    关键点:

    1. 它指的是个常量;
    2. 指针所保存的地址可以改变,然而指针所指向的值却不可以改变;
    3. 指针本身是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化;

    指向常量的常指针:

    const int * const p;
    

    定义:指向常量的指针常量就是一个常量,并且它指向的对象也是一个常量;

    关键点:

    1. 一个指针常量,指向的是一个指针对象;

    2. 它指向的指针对象且是一个常量,即它指向的对象不能变化;

    区分方法:(带有两个const的肯定是指向常量的常指针)

    方法一:看 * 和 const 的排列顺序

    int const * p; //常量指针
    const int * p; //常量指针
    int * const p; //指针常量
    

    方法二:看const离谁近,即从右往左看

    int const * p; //const修饰的是*p,即*p的内容不可通过p改变,但p不是const,p可以修改,*p不可修改
    const int * p; //同上
    int * const p; //const修饰的是p,p是指针,p指向的地址不能修改,但是*p可以修改;
    

    示例:

    int a = 10, b = 20;
    //-------常量指针-------
    const int* p1 = &a;
    a = 300;     //OK,仍然可以通过原来的声明修改值,
    //*p1 = 56;  //Error,*p1是const int的,不可修改,即常量指针不可修改其指向地址
    p1 = &b;     //OK,指针还可以指向别处,因为指针只是个变量,可以随意指向;
    
    //-------指针常量-------//
    int* const p2 = &a;
    a = 500;     //OK,仍然可以通过原来的声明修改值,
    *p2 = 400;   //OK,指针是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化
    //p2 = &b;     //Error,因为p2是const 指针,因此不能改变p2指向的内容
    
    //-------指向常量的常量指针-------//
    const int* const p3 = &a;
    //*p3 = 1;    //Error
    //p3 = &b;    //Error
    a = 5000;    //OK,仍然可以通过原来的声明修改值
    
    展开全文
  • 常量指针与指针常量区别

    千次阅读 2018-11-28 10:34:16
    这样看,常量指针本质是指针,常量修饰它,表示这个指针乃是一个指向常量的指针(变量)。 指针指向的对象是常量,那么这个对象不能被更改。 在C/C++中,常量指针是这样声明的: 1)const int *p; 2)int c...

    三个名词虽然非常绕嘴,不过说的非常准确。用中国话的语义分析就可以很方便地把三个概念区分开。

    一) 常量指针。

    常量是形容词,指针是名词,以指针为中心的一个偏正结构短语。这样看,常量指针本质是指针,常量修饰它,表示这个指针乃是一个指向常量的指针(变量)。

    指针指向的对象是常量,那么这个对象不能被更改

    在C/C++中,常量指针是这样声明的:

    1)const int *p;

    2)int const *p;

    常量指针的使用要注意,指针指向的对象不能通过这个指针来修改,可是仍然可以通过原来的声明修改,也就是说常量指针可以被赋值为变量的地址,之所以叫做常量指针,是限制了通过这个指针修改变量的值。例如:

    int a = 5;

    const int b = 8;

      const int *c = &a; // 这是合法的,非法的是对c的使用

    *c = 6; // 非法,但可以这样修改c指向的对象的值:a = 6;

    const int *d = &b; // b是常量,d可以指向b,d被赋值为b的地址是合法的

      细心的朋友在使用字符串处理函数的时候,应该会注意到这些函数的声明。它们的参数一般声明为常量指针。例如,字符串比较函数的声明是这样的:

    int strcmp(const char *str1, const char *str2);

    可是这个函数却可以接收非常量字符串。例如这段程序:

    char *str1, *str2;

    str1 = "abcde1234";

    str2 = "bcde";

    if(strcmp(str1, str2) == 0)

    {

    printf("str1 equals str2.");

    }

    str1和str2的内容显然是可以更改的,例如可以使用“str1[0] = x;”这样的语句把str1的内容由“abcde1234”变为“xbcde1234”。因为函数的参数声明用了常量指针的形式,就保证了在函数内部,那 个常量不被更改。也就是说,对str1和str2的内容更改的操作在函数内部是不被允许的。(就目前的应用来看,我觉得设置常量指针就是为函数参数声明准 备的,不然还真不知道用在什么地方呢,呵呵!)

    虽然常量指针指向的对象不能变化,可是因为常量指针是一个变量,因此,常量指针可以不被赋初始值,且可以被重新赋值。例如:

    const int a = 12;

    const int b = 15;

    const int *c = &a; // 为了简化代码,很多人习惯赋初始值

    const int *d;

    d = &a; // 这样当然是可以的

    c = &b; // 虽然c已经被赋予初始值,可是仍然可以指向另一个变量

    特点是,const的位置在指针声明运算符*的左侧。只要const位于*的左侧,无论它在类型名的左边或右边,都声明了一个指向常量的指针,叫做常量指针。

    可以这么想,*左侧是常量,指针指向的对象是常量。

    二) 指针常量

    指针是形容词,常量是名词。这回是以常量为中心的一个偏正结构短语。那么,指针常量的本质是一个常量,而用指针修饰它,那么说明这个常量的值应该是一个指针。

    指针常量的值是指针,这个值因为是常量,所以不能被赋值。

    在C/C++中,指针常量这样声明:

    int a;

    int *const b = &a; //const放在指针声明操作符的右侧

    只要const位于指针声明操作符右侧,就表明声明的对象是一个常量,且它的内容是一个指针,也就是一个地址。上面的声明可以这么读,声明了一个常量b,它的值是变量a的地址(变量a的地址,不就是指向变量a的指针吗)。

    因为指针常量是一个常量,在声明的时候一定要给它赋初始值。一旦赋值,以后这个常量再也不能指向别的地址。

    虽然指针常量的值不能变,可是它指向的对象是可变的,因为我们并没有限制它指向的对象是常量。

    因此,有这么段程序:

    char *a = "abcde1234";

    char *b = "bcde";

    char *const c = &a;

      下面的操作是可以的。

      a[0] = 'x'; // 我们并没有限制a为常量指针(指向常量的指针)

    或者

    *c[0] = 'x' // 与上面的操作一致

    三)指向常量的指针常量

    顾名思议,指向常量的指针常量就是一个常量,且它指向的对象也是一个常量。

    因为是一个指针常量,那么它指向的对象当然是一个指针对象,而它又指向常量,说明它指向的对象不能变化。

    在C/C++中,这么声明:

      const int a = 25;

    const int * const b = &a;

    看,指针声明操作符左边有一个const,说明声明的是一个指向常量的指针。再看,指针声明操作符右边有一个const,说明声明的是一个指针常量。前后都锁死了,那么指向的对象不能变,指针常量本身也不能变。细细体味,相信能得其道,下面就不赘述了。

    用一个例子作为总结。虽然字符指针与其它指针的本质是一样的,可是因为字符指针常用来表示字符串,常不好理解。下面就用字符指针来举例。

    char *a = "abcde1234";

    const char *b = "bcde"; // b是指向常量字符串的指针变量

    char *const c = &a;  // c是指向字符指针变量的常量

    const char *const d = &b; // d是指向字符常量的指针常量

    问题来了。

    1)问:因为a是变量,a可以赋值为其它值,如"12345abc"。那么c指向a,当a变化了,c指向什么呢?

    答:仍然指向"abcde1234"。虽然a可以指向别的字符串,可是c仍然指向"abcde1234",也就是a开始指向的对象。

    2)问:a是变量,可以改变a的内容。那么当执行了“a[0] = 'x';”后,c会怎样呢?

    答:c当然还指向a初始指向的字符。不过,这个字符已经变成了'x'。

    3)问:b是指向常量的指针变量,当b指向别的字符串,d怎么样?

    答:d仍然指向b初始的字符串。

    4)问:b可以变化,b指向的字符不能变化,也就是说b[0]不能被重新赋值,可是b[1]可以被重新赋值吗?

    答:原则上b指向的字符是常量,并没有限制下一个字符,应该可以被赋值。可是因为你使用字符串进行了初始赋值,而且编译器是静态编译的,C/C++程序就把b当作字符串指针来处理了,因此,当对下一个字符进行赋值时,编译不能通过。

    其他问题,欢迎补充。

    我编了这样的口诀,记住,应该不难:

    const(*号)左边放,我是指针变量指向常量;

    const(*号)右边放,我是指针常量指向变量;

    const(*号)两边放,我是指针常量指向常量;

    指针变量能改指向,指针常量不能转向!

    要是全都变成常量,锁死了,我不能转向,你也甭想变样!

    展开全文
  • 指针是C语言中的精髓,但也是难点。我这不是我第一次写关于C指针的文章了,只是因为指针对于C来说太重要,而且随着自己编程经历越多,对指针...可以帮大家正确理解C语言中的常量、变量、指针的指针变量之间的相互关系。
  • 常量指针、指针常量的区别

    千次阅读 2021-03-06 16:41:10
    **要有具备扎实指针知识…… 了解引用、指针的一些注意事项: 引用并非对象 引用必须初始化 ...常量指针可以被赋值为变量的地址,之所以叫常量指针,是限制了通过这个指针修改变量的值; 指针还可以指向别

    **要有具备扎实指针知识……
    了解引用指针的一些注意事项:

    • 引用并非对象
    • 引用必须初始化
    • 引用只能绑定在对象上,而不能与字面值或某个表达式的计算结果绑定在一起
    • 类型要严格匹配

    一、常量指针

    定义
    又叫常指针,可以理解为常量的指针,也即这个是指针,但指向的是个常量,这个常量是指针的值(地址),而不是地址指向的值。

    特点

    • 常量指针指向的对象不能通过这个指针来修改,可是仍然可以通过原来的声明修改;
    • 常量指针可以被赋值为变量的地址,之所以叫常量指针,是限制了通过这个指针修改变量的值;
    • 指针还可以指向别处,因为指针本身只是个变量,可以指向任意地址;

    表示形式
    int const* p1; const int* p1;

    二、指针常量

    定义
    本质是一个常量,而用指针修饰它。指针常量的值是指针,这个值因为是常量,所以不能被赋值。

    特点

    • 它是个常量!
    • 指针所保存的地址可以改变,然而指针所指向的值却不可以改变
    • 指针本身是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化;

    表示形式:

    int* const p1;

    三、两者区别

    //-------常量指针------- //
    const int *p1 = &a; a = 200; //OK,仍然可以通过原来的声明修改值,
    // *p1 = 13; //Error,*p1是const int的,不可修改,即常量指针不可修改其指向地址
    p1 = &b; //OK,指针还可以指向别处,因为指针只是个变量,可以随意指向;

    //-------指针常量-------//
    int* const p2 = &a; a = 200; //OK,仍然可以通过原来的声明修改值,初始化的就给它分配地址,可以的(相当于分配初值);
    *p2 = 900; //OK,指针是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化
    //p2 = &b; //Error,因为p2是const 指针,因此不能改变p2指向的内容

    补集一个:

    //-------指向常量的常量指针-------//
    const int* const p3 = &a; //*p3 = 1;
    //Error //p3 = &b; //Error
    a = 10; //OK,仍然可以通过原来的声明修改值

    四、代码实现、实例讲解
    -------常量指针-------

    #include <stdio.h>
    int main()
    {
            int a;
            int b;
            const int *p1 = &a;
            a = 300;     //OK,仍然可以通过原来的声明修改值,
            b = 100;
            //*p1 = 60;  //Error,*p1是const int的,不可修改,即常量指针不可修改其指>向地址
            printf("p1=%p\n",p1);
            printf("p1=%d\n",*p1);
            p1 = &b;     //OK,指针还可以指向别处,因为指针只是个变量,可以随意指向;
            printf("p1=%p\n",p1);
            printf("p1=%d\n",*p1);
            return 0;
    }
    
    

    运行结果:

    p1=0x7fffb29b22d8
    p1=300
    p1=0x7fffb29b22dc
    p1=100

    -------指针常量-------

    #include <stdio.h>
    int main()
    {
    	int a;
    	int b; 
    	int*  const p2 = &a;
    	a = 900;     //OK,仍然可以通过原来的声明修改值,
    	printf("p2的地址=%p\n",p2);
    	printf("p2的值=%d\n",*p2);
    	*p2 = 100;   //OK,指针是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化
    	printf("p2的地址=%p\n",p2);
    	printf("p2的值=%d\n",*p2);
    //	p2 = &b;     //Error,因为p2是const 指针,因此不能改变p2指向的内容	
    	return 0;
    } 
    

    运行结果:

    p2的地址=0060FF08
    p2的值=900
    p2的地址=0060FF08
    p2的值=100

    大结:两者的重要区别,可不可以通过修改地址来改别常量

    展开全文
  • 指针常量与常量指针

    2020-04-29 10:59:32
    指针常量和常量指针都离不开const关键字,我们先来了解一下什么是const关键字,const被用来定义常量,如果将一个变量加上const关键字,则被修饰的变量的值将无法改变。这个变量的值只能被访问,无法被修改。const...
  • 常量指针及指针常量区别(窍门)

    千次阅读 2019-05-11 23:45:50
    常量指针本质是指针,常量修饰它,表示这个指针乃是一个指向常量的指针(变量)。函数传入参数中较多采用。 指针指向的对象是常量,那么这个对象不能被更改。 在C/C++中,常量指针是这样声明的: 1)const int *p...
  • C语言 指针常量和常量指针区别
  • C/C++中指针常量和常量指针用法及区别 前言 指针是一种特殊的变量,指针的值为内存地址。 一、基本概念 1、指针常量:指针常量就是指针本身是常量,换句话说,就是指针的值(内存地址)是常量,不能改变。但是,...
  • 常(量)指针指针就是我们说的指向常量指针,顾名思义,它是用来指向常量的。 用常指针指向常变量实际上,C++规定只能用指向常变量指针指向常变量,普通指针指向它就会报错,原因也很容易理解,我们用普通指针...
  • 一、常量指针:指向常量的指针。 int const *p(const int *p); p = &a; p可以改变指向,可以指向常量和非常量,但不能用*p修改指向变量的值。 二、指针常量:常量,存放的地址不能改变。 int *const p = &...
  • 要理解它们的差别,需要先掌握指针、常量指针、指针常量的概念。 1.指针 指针的本质也就是变量: 它不仅有自己的地址,也有它所存放的值,只不过这个值是地址而已。 int a = 10; int *p = &a; //指针变量...
  • 常量指针,常指针,指针常量,指向常量的指针,这些东西到底是什么鬼,让我纠结了很长时间,每次读的时候都感觉差不多啊,今天终于闹明白了,整理一下 常量指针,其实就是指向常量的指针,故,它本质是一个指针,...
  • 常量指针和指针常量的区别

    万次阅读 多人点赞 2018-05-24 22:57:09
    在面试中我们经常会被面试官问到什么是常量指针,什么又是指针常量。可能第一次被问到都会有些懵逼(大神略过)。我今天就来讲一讲这二者的区别。 下面开始正题。。。。 指针常量 指针常量:顾名思义它就是一个...
  • C++中常量指针和指针常量的区别

    千次阅读 2018-08-03 23:05:04
    常量指针本质是指针,常量修饰它,表示这个指针是一个指向常量的指针(变量),也就是指向一个无法修改的量。 C++中常量指针定义为:const int* a,当然int const * a也可以,不过习惯用第一种了。 使用常量指针时...
  • newp中保存的地址和p中保存的地址完全一样,唯一区别是,newp不再是一个常量指针了。 常量转换,第二层含义是,将非常量转化为常量,具体代码如下 int * p2 = NULL; const int * newP2 = const_cast<const int *&...
  • c++之指针常量和常量指针

    千次阅读 2022-02-21 13:13:23
    指针常量和常量指针 1.常量指针 const int *PtrConst 或者是 int const *PtrConst (即const 在*的左边) 指向常量的指针,这里所说的“常量”其实在解引用时起到所谓常量的作用,并非是指向的变量就是常量,指向的...
  • 很多人初次了解常量指针和指针常量时傻傻分不清,也记不住区别。这里我将送你们一句口诀: 指针常量指指针(这里的指针代表地址) 常量指针指常量(这里常量就是常量) 在代码中如何区分呢? 例如: int *const p; int...
  • 常量指针与指针常量

    2020-07-05 12:39:20
    常量指针与指针常量 常量指针(常指针) 写法: 1.const (数据类型)* + 变量 2.(数据类型) const* + 变量 理解: 1.从字面理解上,常量指针本质上是一个指针,只不过他所指向的值是一个常量。 2.从写法上,const ...
  • 参考链接:...一、基础知识 指向字符串的指针 1: 什么是字符串:用双引号括起来的0个或多个字符。“123” 2: 字符串的结束符号’\0’ '\0’它是一个字符,不是一个字符串 ...
  • 如果在定义指针变量的时候,数据类型前用const修饰,被定义的指针变量就是指向常量的指针变量,指向常量的指针变量成为常量指针。 const int* p = &a; //常量指针 //举个例子 int a = 10; int b = 20; const ...
  • 常量指针和指针常量

    千次阅读 多人点赞 2021-03-10 16:54:37
    一、常量指针 ...注意: 常量指针指向的对象不能通过这个指针来修改,但是因为常量指针本身是一个变量,因此,可以被重新赋值。 #include <iostream> using namespace std; int main() { const
  • 常量指针和指针常量的区别详解

    千次阅读 2017-08-08 08:49:49
    常量指针和指针常量的区别详解
  • C++ 指针常量、常量指针和常指针常量 2014年11月26日 22:12:41 To-Big_Fish 阅读数:4324 https://blog.csdn.net/yujin753/article/details/41523005 1、指针常量 如果在定义指针变量时候,指针变量前用const...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 285,965
精华内容 114,386
热门标签
关键字:

常量指针与变量指针的区别