精华内容
下载资源
问答
  • 1.指针变量:指针值(即指针的指向)可以改变的指针,只能指向变量; 2.指针常量:指针值(即指针的指向)不能改变的指针,只能指向变量,但可以修改指向的实体变量的值; 3.常量指针:指向常量的指针,所以不能...

    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 int MAX=3; const int * iPointer = &MAX; iPointer = new int; 是合法的。 *iPointer=2;//非法 *iPointer += 3;//...

    1)指向常量的指针变量 指针本身的内容可改变,但不会通过该指针改变所指向的内容。例如: const int MAX=3; const int * iPointer = &MAX; iPointer = new int; 是合法的。 *iPointer=2;//非法 *iPointer += 3;//非法,它不可以改变指针所指向的内容。 应该明确,指向常量的指针是可以指向变量的。下列语句成立: int k=5; const int * iPointer = &k;

     2)指向变量的指针常量 (类似引用) 指针本身不会在运行时改变,但是指向内容可以改变。例如: int size = 5; int * const iConstPointer = &size; //指针常量必须在定义的时候初始化确定它的指(内容) iConstPointer = new int;//非法 (* iConstPointer)++;//合法

    3) 指向常量的指针常量 不仅是指针本身不能修改,它所指向的内容也不能通过它改变。 

    展开全文
  • 这样看,常量指针本质是指针,常量修饰它,表示这个指针乃是一个指向常量的指针(变量)。 指针指向的对象是常量,那么这个对象不能被更改。 在C/C++中,常量指针是这样声明的: 1)const int *p; 2)...

    一) 常量指针

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

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

    在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(*号)两边放,我是指针常量指向常量;

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

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

    展开全文
  • 常量指针,常指针,指针常量,指向常量的指针,这些东西到底是什么鬼,让我纠结了很长时间,每次读的时候都感觉差不多啊,今天终于闹明白了,整理一下 常量指针,其实就是指向常量的指针,故,它本质是一个指针,...

    1. 常量指针,常指针,指针常量,指向常量的指针,这些东西到底是什么鬼,让我纠结了很长时间,每次读的时候都感觉差不多啊,今天终于闹明白了,整理一下

    常量指针,其实就是指向常量的指针,故,它本质是一个指针,其次就是常量修饰它。

    例如:

    int const * p;
    const int * p;

    2. 常指针,就是指针常量,故,它是一个常量,并且是作为指针的常量。

    例如:

    int*  const p=&a;

    在这里还要注意一下,因为指针本身是一个常量,所以指针常量声明的时候,必须初始化。而常量指针是不需要的。


    为什么常量指针仍可以指向变量呢?

    这是因为常量指针是为了保证通过指针不能改变其值,这是针对指针而言的。


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

    2020-04-29 10:59:32
    指针常量和常量指针都离不开const关键字,我们先来了解一下什么是const关键字,const被用来定义常量,如果将一个变量加上const关键字,则被修饰的变量的值将无法改变。这个变量的值只能被访问,无法被修改。const...
  • C语言中的变量与常量,顾名思义,可变恒定。 const的存在就是将变量修饰为常量,即让变量变为只读属性。(并不是真的变为常量) 只读的变量: 使变量属性变为只读,像常量一样无法通过赋值进行更改。 定义方式...
  • 指针常量和常量指针区别

    千次阅读 2018-09-20 19:47:10
    指针常量:即指针本身的值是不可改变的,而指针指向的变量的值是可以改变的;...指针一般会指向一个变量,如果该变量成为一个常量,那么该变量的值就不能被修改,即常量指针,指针指向的是一个不可变...
  • C常量指针 指针常量区别

    千次阅读 2012-06-29 10:57:38
    常量指针是指--指向常量的指针,顾名思义,就是指针指向的是常量,即,它不能指向变量,它指向的内容不能被改变,不能通过指针来修改它指向的内容,但是指针自身不是常量,它自身的值可以改变,从而指向另一个常量。...
  • C++常量指针与指针常量区别

    千次阅读 2017-02-27 22:02:15
    C++提供了用const定义常变量的方法,例如:const int a =5;...这里主要区分一下指针常量和常量指针。 1:指针常量:表示:int a = 3,b=4;  int *const p2 = &a; 这里从表达可以看出来,const修饰
  • 常量指针和指针常量的区别 常量指针、指针常量以及指向常量的指针常量概念简要描述
  • C++中常量指针和指针常量的区别

    千次阅读 2018-08-03 23:05:04
    常量指针本质是指针,常量修饰它,表示这个指针是一个指向常量的指针(变量),也就是指向一个无法修改的量。 C++中常量指针定义为:const int* a,当然int const * a也可以,不过习惯用第一种了。 使用常量指针时...
  • 常量指针和指针常量和常量指针常量 **常量指针:**指向常量的指针。 示例一: int n = 10; const int *p = &n; 此时不能通过指针修改数据对象的值,但可以改变指针的指向。比如此时指针p不能改变n的值...
  • 这样看,常量指针本质是指针,常量修饰它,表示这个指针乃是一个指向常量的指针(变量)。 指针指向的对象是常量,那么这个对象不能被更改。 在C/C++中,常量指针是这样声明的: 1)const int *p; 2)int c
  • 常量指针和指针常量的区别剖析

    千次阅读 2019-03-12 11:34:42
    指针常量 指针常量:顾名思义它就是一个常量,但是是指针修饰的。 格式为: int * const p //指针常量 ...因为声明了指针常量,说明指针变量不允许修改。如同次指针指向一个地址该地址不能被修改,但是该地址里...
  • //指针 //(1)指向常量的指针是指一个指向常量指针变量 #include "iostream.h" void main() { const char *name = "(1)指向常量的指针是指一个指向常量指针变量"; cout }
  • #include using namespace std; void f1(int){} void f2(int&){} void f3(int*&){}   int main() ...//a[i]实际上是第i+1行的首地址,且为常量指针    const int
  • 常量指针和指针常量的区别详解

    千次阅读 2017-08-08 08:49:49
    常量指针和指针常量的区别详解
  • 今天看书看到常量指针发现和我以前看到的常量指针怎么是反的,本来以为书上是错的,然后深究一下。其实都没错,是翻译的方式不同而已,其实指的一个意思。可以划分一下: 指向常量的指针和常量指针为一组说法,常量...
  • C++指针常量与常量指针

    千次阅读 2020-07-08 11:21:35
    之前写的是什么玩意——7.8回炉重造更 首先,常量与变量的概念很容易区分,在c++中,常量常用const修饰,即不可变...当一个指针变量指向一个变量时,指针变量本身可以改变,也可以通过指针变量改变变量。如下: int a

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 244,770
精华内容 97,908
关键字:

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