精华内容
下载资源
问答
  • C++ 指针常量、常量指针和常指针常量 2014年11月26日 22:12:41 To-Big_Fish 阅读数:4324 https://blog.csdn.net/yujin753/article/details/41523005 1、指针常量 如果在定义指针变量时候,指针变量前用const...

    C++ 指针常量、常量指针和常指针常量

    2014年11月26日 22:12:41 To-Big_Fish 阅读数:4324

    https://blog.csdn.net/yujin753/article/details/41523005

    1、指针常量

    如果在定义指针变量时候,指针变量前用const修饰,被定义的指针变量就变成了一个指针类型的常变量,指针类型的常变量简称为指针常量。

    格式如下

     

    数据类型  *   const  指针变量=变量名;

    修饰符const与指针变量紧邻,说明指针变量不允许修改,既然指针变量的值不能修改,所以一定要在定义的时候给定初值(指向一个确定存在的地方)

     

    如下

     

    
     
    1. <span style="font-size:18px;">char * const p="ABCDEF";

    2.  
    3. p=NULL;//错误,指针常量不能再改变

    4. p="1234";//错误

    5. p=(char *)q;//错误</span>


    可以这样理解

     

          

    如:修改指向0x123456的内容   *P=‘B’;//正确

    2、常量指针

    如果在定义指针变量的时候,数据类型前用const修饰,被定义的指针变量就是指向常量的指针变量,指向常量的指针变量称为常量指针,格式如下

     

    const 数据类型  *指针变量=变量名;

    或者     数据类型  const  * 指针变量=变量名;

     

    定义一个常量指针后,指针指向的值就不能被改变,即不能通过指针变量直接更改指针指向的值

     

     

    
     
    1. <span style="font-size:18px;">const char *P="ABCDEF";

    2.  
    3. *P='1';//错误,视图更改指针指向的值

    4. p[1]='1';//错误

    5. p=NULL;//正确,视图修改指针的位置,而不是修改指针指向的内容</span>


     

     

    3、常指针常量

       格式为

     

      const   数据类型 * const 指针变量=变量名;

    数据类型 const  *const 指针变量=变量名;

     

    指针不能改变,指针指向的值也不能改变

     

     

    
     
    1. <span style="font-size:18px;">char *q;

    2. const char * const p="ABCDEF";//定义了一个常量常指针

    3. q=p;//错误,试图讲一个常指针赋值给非常指针

    4. p=q;//错误,试图修改指针常量的值,如1

    5. *p=‘1’;//错误,试图修改指针指向的值,如2

    6. p[1]='1';//错误,如2

    7. p=NULL;//错误,如1</span>

     

     

     

     

     

    常指针和指向常量的指针的区别

    2016年10月10日 17:27:15 zhanghuaichao 阅读数:4741

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zhanghuaichao/article/details/52779572

    最近在学习引用,有一些学习心得,记录如下:

    1.引用是变量的别名

    int a;

    int b&=a;

    要注意引用只有声明,而没有定义,并且引用必须在声明的时候进行初始化,一旦与某个变量关联起来,就将一直效忠于它。

    2.引用的实质是指针。

    其中引用出现在C++中的理由,也是为了在一定程度上回避一下C语言中的指针问题。

    引用相当于  常指针

     int  a;

    int &b=a;

    //实际上是下述代码的伪装表示

    int  *  const  pt= &a;

     其中引用 b扮演的角色与表达式 *pt 是完全相同的。

    3.说完了第二个问题就该说说常指针和指向常量的指针的区别了。

    先说一下概念  常指针  是指针指向的位置不能改变,也就是指针的指只能赋值一次。

                            指向常量的指针 是指指针指向的对象不能改变,也就是说不能通过这个指针来改变指向对象的指,而指针自身的指向是可以改变的。

    再说一下具体的形式

    const char *p;

    char const *p;

    以上两种是指向常量的指针。

    char * const p;

    是常指针。

    区分就是看  * 和const 谁离指针变量名 p近,如果是  * 离的近,表示该指针指向一个常量。

    反过来如果是 const离的近,则代表是一个常指针。

    4.

    const int n=5;

    int const n=5;

    完全等价。

     

     

    C++关键字(1)——const

    部分内容来自作者JuKevin

     

    1. const修饰普通变量和指针

    const修饰变量,一般有两种写法:

    const TYPE value;

    TYPE const value;

    这两种写法在本质上是一样的。它的含义是:const修饰的类型为TYPE的变量value是不可变的。

    对于一个非指针的类型TYPE,无论怎么写,都是一个含义,即value只不可变。

    例如:

    const int nValue;         //nValue是const

    int const nValue;    // nValue是const

    但是对于指针类型的TYPE,不同的写法会有不同情况,例如:

    A. const char *pContent;

    B. char * const pContent;

    C. char const *pContent;

    D. const char* const pContent;

     

    对于前三种写法,我们可以换个方式,给其加上括号

    A. const (char) *pContent;

    B. (char*) const pContent;

    C. (char) const *pContent;

    这样就一目了然。根据对于const修饰非指针变量的规则,很明显,A=C.

     

    - 对于A,C, const修饰的类型为char的变量*pContent为常量,因此,pContent的内容为常量不可变.

    - 对于B, 其实还有一种写法: const (char*) pContent;

     含义为:const修饰的类型为char*的变量pContent为常量,因此,pContent指针本身为常量不可变.

    - 对于D, 其实是A和B的混合体,表示指针本身和指针内容两者皆为常量不可变

     

    总结:

    (1)  指针本身是常量不可变

    (char*) const pContent;

    const (char*) pContent;

     

    (2)  指针所指向的内容是常量不可变

    const (char) *pContent;

    (char) const *pContent;

     

    (3)  两者都不可变

    const char* const pContent;

     

    还有其中区别方法:

    沿着*号划一条线,

    如果const位于*的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;

    如果const位于*的右侧,const就是修饰指针本身,即指针本身是常量。

     

     

    2. const修饰函数参数

    const修饰函数参数是它最广泛的一种用途,它表示函数体中不能修改参数的值(包括参数本身的值或者参数其中包含的值)。

     

    void function(const int Var); //传递过来的参数在函数内不可以改变(无意义,因为Var本身就是形参)

    void function(const char* Var); //参数指针所指内容为常量不可变

    void function(char* const Var); //参数指针本身为常量不可变(也无意义,因为char* Var也是形参)

     

    参数为引用,为了增加效率同时防止修改。修饰引用参数时:

    void function(const Class& Var);//引用参数在函数内不可以改变

    void function(const TYPE& Var); //引用参数在函数内为常量不可变

     

    3. const 修饰函数返回值

    const修饰函数返回值其实用的并不是很多,它的含义和const修饰普通变量以及指针的含义基本相同。

    (1) const int fun1() 这个其实无意义,因为参数返回本身就是赋值。

    (2) const int * fun2()

    调用时 const int *pValue = fun2();

    我们可以把fun2()看作成一个变量,那么就是我们上面所说的1.(1)的写法,即指针内容不可变。

    (3) int* const fun3()

    调用时 int * const pValue = fun2();

    我们可以把fun2()看作成一个变量,那么就是我们上面所说的1.(2)的写法,即指针本身不可变。

     

    4. const修饰类对象/对象指针/对象引用

    const修饰类对象表示该对象为常量对象,其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。

    const修饰的对象,该对象的任何非const成员函数都不能被调用,因为任何非const成员函数会有修改成员变量的企图。

    例如:

    class AAA

    {
       void func1();

    void func2() const;

    }

    const AAA aObj;

    aObj.func1(); ×

    aObj.func2(); 正确

     

    const AAA* aObj = new AAA();

    aObj->func1(); ×

    aObj->func2(); 正确

     

    5. const修饰成员变量

    const修饰类的成员变量,表示成员常量,不能被修改,同时它只能在初始化列表中赋值。

     

    class A

    {

       …

       const int nValue;       //成员常量不能被修改

       …

       A(int x): nValue(x) {}; //只能在初始化列表中赋值

    }

     

    6. const修饰成员函数

    const修饰类的成员函数,则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。

     

    class A

    {

       …

    void function()const; //常成员函数, 它不改变对象的成员变量. 也不能调用类中任何非const成员函数

    }

    对于const类对象/指针/引用,只能调用类的const成员函数,因此,const修饰成员函数的最重要作用就是限制对于const对象的使用。

     其实,有一个方法可以改变,使得常量成员函数可以改变成员变量,即在成员变量的前面加上修饰符mutable.

    代码如下:

    class A

    {

        public:

        mutable int m_Count; //加上修饰符,正确

        int func1( ) const

          {

                 m_Count++;

           }

    }

    7. const常量与define宏定义的区别

    (1) 编译器处理方式不同

    define宏是在预处理阶段展开。

    const常量是编译运行阶段使用。

    (2) 类型和安全检查不同

    define宏没有类型,不做任何类型检查,仅仅是展开。

    const常量有具体的类型,在编译阶段会执行类型检查。

    (3) 存储方式不同

    define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。

    const常量会在内存中分配(可以是堆中也可以是栈中)。

     

    展开全文
  • 文章移至: C++ 指针常量和常量指针的区别
    展开全文
  • 1、指针常量 如果在定义指针变量时候,指针变量前用const修饰,被定义的指针变量就变成了一个指针类型的常变量,指针类型的常变量简称为指针常量。 格式如下 数据类型 * const 指针变量=变量名; 修饰符const与...

    1、指针常量

    如果在定义指针变量时候,指针变量前用const修饰,被定义的指针变量就变成了一个指针类型的常变量,指针类型的常变量简称为指针常量。

    格式如下

    数据类型  *   const  指针变量=变量名;

    修饰符const与指针变量紧邻,说明指针变量不允许修改,既然指针变量的值不能修改,所以一定要在定义的时候给定初值(指向一个确定存在的地方)

    如下

    <span style="font-size:18px;
    ">char * const p="ABCDEF";
    p=NULL;//错误,指针常量不能再改变
    p="1234";//错误
    p=(char *)q;//错误</span>

    可以这样理解


          

    如:修改指向0x123456的内容   *P=‘B’;//正确

    2、常量指针

    如果在定义指针变量的时候,数据类型前用const修饰,被定义的指针变量就是指向常量的指针变量,指向常量的指针变量称为常量指针,格式如下                           

    const 数据类型  *指针变量=变量名;

    或者     数据类型  const  * 指针变量=变量名;

    定义一个常量指针后,指针指向的值就不能被改变,即不能通过指针变量直接更改指针指向的值

    <span style="font-size:18px;
    ">const char *P="ABCDEF";
    *P='1';//错误,视图更改指针指向的值
    p[1]='1';//错误
    p=NULL;//正确,视图修改指针的位置,而不是修改指针指向的内容</span>

     


    3、常指针常量

       格式为

      const   数据类型 * const 指针变量=变量名;

    数据类型 const  *const 指针变量=变量名;

    指针不能改变,指针指向的值也不能改变

     

    <span style="font-size:18px;">char *q;
    const char * const p="ABCDEF";//定义了一个常量常指针
    q=p;//错误,试图讲一个常指针赋值给非常指针
    p=q;//错误,试图修改指针常量的值,如1
    *p=‘1’;//错误,试图修改指针指向的值,如2
    p[1]='1';//错误,如2
    p=NULL;//错误,如1</span>

    --------------------- 
    作者:To-Big_Fish 
    来源:CSDN 
    原文:https://blog.csdn.net/yujin753/article/details/41523005 

    其实这个很好理解 明白p,*p所代表的意思就好了,p是一个指针变量的名字,那他表示的是此指针变量指向的内存地址,而*p表示此指针指向的内存地址中存放的内容,一般是一个和指针类型一致的变量或者常量。

     

    展开全文
  • 指针常量与常量指针的翻译就好比机器学习中Regularization翻译成正则化一样,讲真,正则化这个说法确实要比规则化显得高端些,但是到了理解的时候,还是要按照规则化理解。指针常量与常量指针这个概念是一样的,英文...

    吐槽一下:
    指针常量与常量指针的翻译就好比机器学习中Regularization翻译成正则化一样,讲真,正则化这个说法确实要比规则化显得高端些,但是到了理解的时候,还是要按照规则化理解。

    指针常量与常量指针这个概念是一样的,英文里没有pointer const这个词,只有pointer to const和const pointer这两个词。

    而不管是指针常量还是常量指针他们的区别其实就是const关键字的位置,下面直接根据声明方式不同解释二者的区别:
    在只有一个关键字const的情况下,声明有三种方式:

    //1
    const int* p;
    //2 
    int const* p;
    //3 
    int * const p;
    

    其中1和2是一种,这种情况下不能使用指针修改指向数据的值,但是也仅仅是不能使用指针p修改而已,p指向的值本身如果不是常量的话那么还可以直接对值修改,举个例子:

    int a = 5;
    const int* p = &a;
    a = 4;//合法
    *p = 3;//不合法
    

    由于这个特点,通常把const int* p的形式作为函数的参量,以表示函数不会用这个指针修改数据,比如我们有一个子函数是想打印一个数组,那么我们可以将函数声明写成这样:

    void printfarr(const int *arr,int n);
    

    如此,当主函数中调用该子函数,并打印主函数中的变量array的时候,永远不会出现array变化的情况,但是主函数自身想要修改array显然是可以的。所以被指向的数据的值到底能不能改变根本不由指针的声明方式决定,而是该数据本身是常量还是变量

    int a = 5;
    const int b = 5;
    const int* p = &a;
    a = 4;//合法
    *p = 3;//不合法
    p = &b;//合法
    b = 4;//不合法
    *p = 3;//不合法
    

    而对于3,它的作用是保证指针不会指向别处,也就是一旦用这种方式声明并初始化,指针指向的地址永远不会发生变化,但是其中的值却可以通过指针改变:

    int a = 5;
    int b = 6;
    int * const p = &a;
    *p = 4;//合法
    p = &b;//不合法
    

    以上就是所谓的指针常量与常量指针所包含的概念,在这里标个号:
    1,2暂时称为第一类,3暂时称为第二类,那么第一类和第二类到底哪个叫做指针常量,那个叫做常量指针呢?说实话我都不知道指针常量与常量指针的叫法是不是够官方,我只能说概念非常混淆,而且其实它的两个名字并不重要,关键的是声明方式与作用的区别。

    百度百科认为第一类应该叫做常量指针,第二类叫做指针常量
    这里写图片描述
    这里写图片描述

    但是在**《C Primer Plus》中将第一类叫做指向常量的指针**,也就是在文章开头提到的pointer to const,那么第二类也就是const pointer了,但是这样一来,他就已经和百度百科的说法反了。

    到目前为止我还没有找到更权威的说法,维基百科找不到这两个词,所以我们干脆不要去理会第一类与第二类到底该叫做什么名字,因为他们的声明方式与作用是决定清晰的就足够了。

    上面说的情况,对于指针的修饰都只用了一个const关键字,还有两个const一起用的时候,此时的结果就是指针不能修改指向的数据,指针不能指向别的地方:

    int a = 5;
    int b = 6; 
    const int * const p = &a;//合法
    *p = 4;//不合法
    p = &b;//不合法
    a = 7;//合法
    

    最后还有一个最严格的情况,就是数据本身就是常量,而且常量的地址不允许赋值给普通指针,这样一来数据自身不能改变,指针不能该数据,指针不能指向别处。

    const int a = 5;
    int b = 6; 
    int * const q = &a;//不合法
    const int * const p = &a;//合法
    *p = 4;//不合法
    p = &b;//不合法
    a = 7;//不合法
    
    展开全文
  • C++指针常量与常量指针

    千次阅读 2020-07-08 11:21:35
    指针常量:本质是一个常量,并且使用指针来修饰它,那么说明这个常量的值应该是一个指针,其格式应为:int * const p。 常量指针:而常量指针本质是指针,并且这个指针乃是一个指向常量的指针。其格式为:int const ...
  • 指针常量和常量指针的书写区别就是 “const”和“p”的位置指针常量,指向const的指针,指针可以修改,指向的数据不可以修改 常量指针,指针本事是常量,指针不可以修改,指向的数据可以修改
  • 1、指针常量指针常量的本质是一个常量,并且使用指针来修饰它,那么说明这个常量的值应该是一个指针。**英文名:**pointer const定义格式 类型 * const p;2、常量指针常量指针本质是指针,常量修饰它,表示这个指针...
  • 指针常量:指向常量的地址,不允许改变指向地址,指向位置的变量值能被改变(p不可以变) (* const p) 常量指针:指向常量的指针,指针指向的对象不能通过这个指针来修改,可是仍然可以通过原来的声明修改,也就是说量...
  • 本文是根据崔毅东,杨谈老师c++程序设计(面向对象进阶)...常指针常量即为常量指针常量,顾名思义具有常量指针和指针常量二者的特性 示例: 上左:普通指针 上右:常量指针 下左:指针常量 下右:常指针常量 #i...
  • C++常量指针、指针常量 记忆法: 常量指针表示方法: const double * p = &a; //const读作常量,*读作指针,常量指针 double const *p = &a; 指针常量通常表示为: double * const ptr; //const读作常量...
  • C++中常量指针和指针常量的区别 一、常量指针 常量指针本质是指针,常量修饰它,表示这个指针是一个指向常量的指针(变量),也就是指向一个无法修改的量。 C++中常量指针定义为:const int* a,当然int const * ...
  • 【C/C++】常量指针、指针常量以及指向常量的指针常量    文/快乐鸟    三个名词虽然非常绕嘴,不过说的非常准确。用中国话的语义分析就可以很方便地把三个概念区分开。    一)常量指针。    常量...
  • 本篇博文主要记录近日学习的常量指针、指针常量和引用
  • C++11使用nullptr关键字,是表达更准确,类型安全的空指针 指向常量指针 不能通过指向常量指针改变所指对象的值,但指针本身可以改变,可以指向另外的对象。 例 int a; const ...
  • 常量指针,指向常量的指针,这个常量指的是地址,指针对应的值不可以...指针常量,可以被赋值,指针常量指向的地址为常量,不可以改变,但是地址对应的值可以改变 常量指针:const type *p 指针常量:type * const p
  • 指针常量 是指--指针本身是常量。它指向的地址是不可改变的,但地址里的内容可以通过指针改变。它指向的地址将伴其一生,直到生命周期结束。有一点需要注意的是,指针常量在定义时必须同时赋初值。  使用方法 常量...
  • 指针常量(常指针)   首先是一个常量,其次该常量是个指针。因为是一个指针类型的常量,所以定义时必须初始化一个变量的地址,且始终指向该地址不能被更改即只能赋值一次,但地址中存放的内容可以被更改。 通过...
  • "font-size:18px;...// 指针常量 const int *const p;//常量指针常量 int const * const p;//常量指针常量  三个名词演变出了五中形式,之所以这样是因为 const int *与int const *是一样的,我是
  • 理清C++常量指针和指针常量这团乱麻
  • 指针常量,指向一块区域,这块区域可读可写,但是指针的值初始后就不能改,类似于一般常量。 const char * const p; 上面两种类型的综合,指针指向的区域不可写,可读。指针初始化后不能改。 至于有什么用,看具体...
  • C++中定义指针变量会分配一个4字节(32位)的内存块用来存储指向数据的地址,如果指针常量结合会有什么问题呢? 通过指针的定义我们可以看出,指针类型会牵扯到两个概念,指针本身(4字节的内存块)和指向数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 144,088
精华内容 57,635
关键字:

c++指针常量

c++ 订阅