精华内容
下载资源
问答
  • const

    万次阅读 多人点赞 2019-05-02 20:11:46
    const修饰的数据类型是指常类型,常类型的变量或对象的值是不能被更新的。 目的 编辑 const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点。 主要作用 编辑 (1)可以定义...

    const修饰的数据类型是指常类型,常类型的变量或对象的值是不能被更新的。

    目的

    编辑

    const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点。

    主要作用

    编辑

    (1)可以定义const常量,具有不可变性。 
      例如:const int Max=100; Max++会产生错误; 
      (2)便于进行类型检查,使编译器对处理内容有更多了解,消除了一些隐患。
      例如: void f(const int i) { .........} 编译器就会知道i是一个常量,不允许修改; 
      (3)可以避免意义模糊的数字出现,同样可以很方便地进行参数的调整和修改。 同宏定义一样,可以做到不变则已,一变都变!
      如(1)中,如果想修改Max的内容,只需要它修改成:const int Max=you want;即可!

    (4)可以保护被修饰的东西,防止意外的修改,增强程序的健壮性。 还是上面的例子,如果在函数体内修改了i,编译器就会报错; 
      例如: void f(const int i) { i=10;//error! } 
      (5) 可以节省空间,避免不必要的内存分配。 例如: 
      #define PI 3.14159 //常量宏 
      const double Pi=3.14159; //此时并未将Pi放入ROM中 ...... 
      double i=Pi; //此时为Pi分配内存,以后不再分配! 
      double I=PI; //编译期间进行宏替换,分配内存 
      double j=Pi; //没有内存分配 
      double J=PI; //再进行宏替换,又一次分配内存! 
      const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是像#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干份拷贝。 
      (6) 提高了效率。 
      编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

    变量与常量

    编辑

    例:为什么下面的例子在使用一个const变量来初始化数组,ANSI C的编译器会报告一个错误呢?

    const int n = 5;

    int a[n];

    答案与分析:

    1)这个问题讨论的是“常量”与“只读变量”的区别。常量,例如5, "abc",等,肯定是只读的,因为常量是被编译器放在内存中的只读区域,当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值,只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符(Qualifier)。上述代码中变量n被修饰为只读变量,可惜再怎么修饰也不是常量。而ANSI C规定数组定义时长度必须是“常量”(C99标准,数组下标可以用变量来表示),“只读变量”也是不可以的,“常量”不等于“不可变的变量”。但是在C++中,局部数组是可以使用变量作为其长度的。

    2)但是在标准C++中,这样定义的是一个常量,这种写法是对的。实际上,根据编译过程及内存分配来看,这种用法本来就应该是合理的,只是ANSI C对数组的规定限制了它(实际上用GCC或VS2005编译以上代码,确实没有错误产生,也没有给出警告)。

    3)那么,在ANSI C中用什么来定义常量呢?答案是enum类型和#define宏,这两个都可以用来定义常量。

    限定内容

    编辑

    例:下面的代码编译器会报一个错误,请问,哪一个语句是错误的呢?

    typedef char * const pStr;

    char string[4] = "bbc";

    const char *p1 =" string"; //1式

    const pStr p2 =" string"; //2式

    p1++;

    p2++;

    答案与分析:

    问题出在p2++上。

    1)const使用的基本形式: const type m;限定m不可变。替换基本形式中的m为1式中的*p1,替换后const char *p1;限定*p1不可变,当然p1是可变的,因此问题中p1++是对的。替换基本形式中的type为2式中的pStr,替换后const pStr m;限定m不可变,题中的pStr就是一种新类型,因此问题中p2不可 [1]  变,p2++是错误的。

    指针举例

    编辑

    例一

    下面分别用const限定不可变的内容是什么?

    1)const在前面

    const int nValue; //int是const

    const char *pContent; //char是const, pContent可变

    const char* const pContent; //pContent和*pContent都是const

    2)const在后面,与上面的声明对等

    int const nValue; //nValue是const

    char const * pContent; //*pContent是const, pContent可变

    char* const pContent; //pContent是const,*pContent可变

    char const* const pContent; //pContent和*pContent都是const

    答案与分析:

    const和指针一起使用是C语言中一个很常见的困惑之处,在实际开发中,特别是在看别人代码的时候,常常会因为这样而不好判断作者的意图,下面讲一下我的判断原则:

    const只修饰其后的变量,至于const放在类型前还是类型后并没有区别。如:const int a和int const a都是修饰a为const。注意*不是一种类型,如果*pType之前是某类型,那么pType是指向该类型的指针

    一个简单的判断方法:指针运算符*,是从右到左,那么如:char const * pContent,可以理解为char const (* pContent),即* pContent为const,而pContent则是可变的。 [1] 

    例二

    int const * p1,p2;

    p2是const;(*p1)是一整体,因此(*p1)是const,但p1是可变的。int * p1,p2只代表p1是指向整型的指针,要表示p1、p2都是指针是需写成int * p1,* p2。所以无论是* const p1,p2还是const * p1,p2,里面的*都是属于p1的。

    例三

    int const * const p1,p2;

    p2是const,是前一个const修饰的,*p1也被前一个const修饰,而p1被后一个const修饰。

    例四

    int * const p1,p2;

    p1是const,(* const p1)是整体,所以const不修饰p2。

    例五

    指针指向及其指向变量的值的变化

    const在*的左边,则指针指向的变量的值不可直接通过指针改变(可以通过其他途径改变);在*的右边,则指针的指向不可变。简记为“左定值,右定向”。

    1)指针指向的变量的值不能变,指向可变

    int x = 1;

    int y = 2;

    const int* px = &x;

    int const* px = &x; //这两句表达式一样效果

    px = &y; //正确,允许改变指向

    *px = 3; //错误,不允许改变指针指向的变量的值

    2)指针指向的变量的值可以改变,指向不可变

    int x = 1;

    int y = 2;

    int* const px = &x;

    px = &y; //错误,不允许改变指针指向

    *px = 3; //正确,允许改变指针指向的变量的值

    3)指针指向的变量的值不可变,指向不可变

    int x = 1;

    int y = 2;

    const int* const px = &x;

    int const* const px = &x;

    px = &y; //错误,不允许改变指针指向

    *px = 3; //错误,不允许改变指针指向的变量的值

    补充

    在c中,对于const定义的指针,不赋初值编译不报错,

    int* const px;这种定义是不允许的。(指针常量定义的时候对其进行初始化)

    int const *px;这种定义是允许的。(常指针可以再定义的时候不初始化)

    但是,在C++中

    int* const px;和const int* const px;会报错,const int* px;不报错。

    必须初始化指针的指向int* const px = &x;const int* const px=&x;

    强烈建议在初始化时说明指针的指向,防止出现野指针!

    展开全文
  • CONST

    2015-07-14 17:45:36
    const是一个C语言的关键字,它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。另外,在观看别人代码的时候,清晰理解const所起的作用,对理解对方的程序也有一些帮助。另外CONST在...
    const是一个C语言的关键字,它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。另外,在观看别人代码的时候,清晰理解const所起的作用,对理解对方的程序也有一些帮助。另外CONST在其他编程语言中也有出现,如C++、PHP5、C#.net、HC08 C。
    中文名
    C语言的关键字
    外文名
    const
    所属领域
    计算机
    格    式
    C++、PHP5

    1定义编辑


      常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的。(当然,我们可以偷梁换柱进行更新:)

    2目的编辑

    const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点。

    3主要作用编辑

    (1)可以定义const常量,具有不可变性。 
      例如:const int Max=100; Max++会产生错误; 
      (2)便于进行类型检查,使编译器对处理内容有更多了解,消除了一些隐患。
      例如: void f(const int i) { .........} 编译器就会知道i是一个常量,不允许修改; 
      (3)可以避免意义模糊的数字出现,同样可以很方便地进行参数的调整和修改。 同宏定义一样,可以做到不变则已,一变都变!
      如(1)中,如果想修改Max的内容,只需要:const int Max=you want;即可! 
      (4)可以保护被修饰的东西,防止意外的修改,增强程序的健壮性。 还是上面的例子,如果在函数体内修改了i,编译器就会报错; 
      例如: void f(const int i) { i=10;//error! } 
      (5) 可以节省空间,避免不必要的内存分配。 例如: 
      #define PI 3.14159 //常量宏 
      const double  Pi=3.14159; //此时并未将Pi放入RAM中 ...... 
      double i=Pi; //此时为Pi分配内存,以后不再分配! 
      double I=PI; //编译期间进行宏替换,分配内存 
      double j=Pi; //没有内存分配 
      double J=PI; //再进行宏替换,又一次分配内存! 
      const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是像#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干份拷贝。 
      (6) 提高了效率。 
      编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。

    4变量与常量编辑

    例:为什么下面的例子在使用一个const 变量 来初始化 数组 ,ANSI C的 编译器 会报告一个错误呢?
    const  int n = 5;
    int a[n];
    答案与分析:
    1)这个问题讨论的是“ 常量”与“只读变量”的区别。常量,例如5, "abc",等,肯定是只读的,因为常量是被编译器放在内存中的只读区域,当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值,只不过这个值由 编译器限定不允许被修改。 C语言关键字const就是用来限定一个变量不允许被改变的 修饰符(Qualifier)。上述代码中变量n被修饰为只读变量,可惜再怎么修饰也不是常量。而ANSI C规定 数组定义时长度必须是“常量”,“只读变量”也是不可以的,“常量”不等于“不可变的变量”。但是在C++中,局部数组是可以使用变量作为其长度的。
    2)但是在标准C++中,这样定义的是一个常量,这种写法是对的。实际上,根据编译过程及 内存分配来看,这种用法本来就应该是合理的,只是ANSI C对数组的规定限制了它(实际上用GCC或VS2005编译以上代码,确实没有错误产生,也没有给出警告)。
    3)那么,在ANSI C中用什么来定义 常量呢?答案是enum类型和#define宏,这两个都可以用来定义常量。

    5限定内容编辑

    例:下面的代码 编译器 会报一个错误,请问,哪一个语句是错误的呢?
    typedef char * pStr;
    char string[4] = "bbc";
    const char *p1 =" string"; //1式
    const pStr p2 =" string"; //2式
    p1++;
    p2++;
    答案与分析:
    问题出在p2++上。
    1)const使用的基本形式: const type m;限定m不可变。替换基本形式中的m为1式中的*p1,替换后const char *p1;限定*p1不可变,当然p1是可变的,因此问题中p1++是对的。替换基本形式中的type为2式中的pStr,替换后const pStr m;限定m不可变,题中的pStr就是一种新类型,因此问题中p2不可 [1]   变,p2++是错误的。

    6指针举例编辑

    例一

    下面分别用const限定不可变的内容是什么?
    1)const在前面
    const int nValue; //nValue是const
    const char *pContent; //*pContent是const, pContent可变
    const char* const pContent; //pContent和*pContent都是const
    2)const在后面,与上面的声明对等
    int const nValue; //nValue是const
    char const * pContent; //*pContent是const, pContent可变
    char* const pContent; //pContent是const,*pContent可变
    char const* const pContent; //pContent和*pContent都是const
    答案与分析:
    const和 指针一起使用是C语言中一个很常见的困惑之处,在实际开发中,特别是在看别人代码的时候,常常会因为这样而不好判断作者的意图,下面讲一下我的判断原则:
    const只修饰其后的变量,至于const放在类型前还是类型后并没有区别。如:const int a和int const a都是修饰a为const。注意*不是一种类型,如果*pType之前是某类型,那么pType是指向该类型的指针
    一个简单的判断方法: 指针运算符*,是从右到左,那么如:char const * pContent,可以理解为char const (* pContent),即* pContent为const,而pContent则是可变的。 [1]  

    例二

    int const * p1,p2;
    p2是const;(*p1)是一整体,因此(*p1)是const,但p1是可变的。int * p1,p2只代表p1是指向整型的指针,要表示p1、p2都是指针是需写成int * p1,* p2。所以无论是* const p1,p2还是const * p1,p2,里面的*都是属于p1的。

    例三

    int const * const p1,p2;
    p2是const,是前一个const修饰的,*p1也被前一个const修饰,而p1被后一个const修饰。

    例四

    int * const p1,p2;
    p1是const,(* const p1)是整体,所以const不修饰p2。

    例五

    指针指向及其指向变量的值的变化
    const在*的左边,则指针指向的变量的值不可直接通过指针改变(可以通过其他途径改变);在*的右边,则指针的指向不可变。简记为“左定值,右定向”。
    1)指针指向的变量的值不能变,指向可变
    int x = 1;
    int y = 2;
    const int* px = &x;
    int const* px = &x; //这两句表达式一样效果
    px = &y; //正确,允许改变指向
    *px = 3; //错误,不允许改变指针指向的变量的值
    2)指针指向的变量的值可以改变,指向不可变
    int x = 1;
    int y = 2;
    int* const px = &x;
    px = &y; //错误,不允许改变指针指向
    *px = 3; //正确,允许改变指针指向的变量的值
    3)指针指向的变量的值不可变,指向不可变
    int x = 1;
    int y = 2;
    const int* const px = &x;
    int const* const px = &x;
    px = &y; //错误,不允许改变指针指向
    *px = 3; //错误,不允许改变指针指向的变量的值

    补充

    在c中,对于const定义的指针,不赋初值编译不报错,
    int* const px;这种定义是不允许的。(指针常量定义的时候对其进行初始化)
    int const *px;这种定义是允许的。(常指针可以再定义的时候不初始化)
    但是,在C++中
    int* const px;和const int* const px;会报错,const int* px;不报错。
    必须初始化指针的指向int* const px = &x;const int* const px=&x;
    强烈建议在初始化时说明指针的指向,防止出现野指针!
    展开全文
  • 改变const值的方式

    2014-09-10 10:18:48
    一种改变const值的方式是使用const_cast类型转换符,将const变量转换为一个该变量的引用,通过这个引用去改变值,这种方法的实质就是用地址改变内存的值。如下实例:  struct SA {  int i = 0;  };  ...
    一种改变const值的方式是使用const_cast类型转换符,将const变量转换为一个该变量的引用,通过这个引用去改变值,这种方法的实质就是用地址改变内存的值。如下实例:

             struct  SA  {
             int  i = 0;
         };

           const SA sa;
           cout << sa.i << endl;
           SA &sb = const_cast<SA&>(sa);
           sb.i = 11;
           cout << sa.i << endl;


    上述这种方式中对象sa是存储在内存中的,并且这个内存在系统中是可更改的,所以我们 可以利用上述这种方式来做改变。
    考虑下面的实例:
             const  int  i = 0;
              int  &b =  const_cast < int    &>(i);
            b = 10;
            cout << i << endl;
            cout << b << endl;


    结果将不如人所料,i输出的值还是0,b输出的值是10.这是什么原因呢?这主要是因为C++编译器中const的实现机制的问题。在C++中,const会被看成是一个常量,所以像数值,字符串这类的值,编译器都会将其放入文字常量区,这也是python中的处理方式。当声明一个引用类型的b时,编译器为他在内存中(栈,不是文字常量区)分配空间,因此是可以改变的。那么我们怎么改变i的值呢?想办法获取此时0在文字常量区的地址,将其改变会不会是一种方式呢?
    展开全文
  • 关于C++ const 的全面总结

    万次阅读 多人点赞 2009-04-30 08:54:00
    C++中的const关键字的用法非常灵活,而使用const将大大改善程序的健壮性,本人根据各方面查到的资料进行总结如下,期望对朋友们有所帮助。Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型,...

        C++中的const关键字的用法非常灵活,而使用const将大大改善程序的健壮性,本人根据各方面查到的资料进行总结如下,期望对朋友们有所帮助。

    Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的。

     

    一、Const作用

       如下表所示:

    No.

    作用

    说明

    参考代码

    1

    可以定义const常量

     

    const int Max = 100; 

    2

    便于进行类型检查

    const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查,而对后者只进行字符替换,没有类型安全检查,并且在字符替换时可能会产生意料不到的错误

    void f(const int i) { .........}
          //对传入的参数进行类型检查,不匹配进行提示

    3

    可以保护被修饰的东西

    防止意外的修改,增强程序的健壮性。

    void f(const int i) { i=10;//error! }
          //如果在函数体内修改了i,编译器就会报错

    4

    可以很方便地进行参数的调整和修改

    同宏定义一样,可以做到不变则已,一变都变

     

    5

    为函数重载提供了一个参考

     

    class A
    {
               ......
      void f(int i)       {......} //一个函数
      void f(int i) const {......} //上一个函数的重载
               ......
    };

    6

    可以节省空间,避免不必要的内存分配

    const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝

    #define PI 3.14159         //常量宏
    const doulbe  Pi=3.14159;  //此时并未将Pi放入ROM中
                  ......
    double i=Pi;   //此时为Pi分配内存,以后不再分配!
    double I=PI;  //编译期间进行宏替换,分配内存
    double j=Pi;  //没有内存分配
    double J=PI;  //再进行宏替换,又一次分配内存!

    7

     提高了效率

    编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高

     

     

     

     

    二、Const的使用

    1定义常量
    (1)const修饰变量,以下两种定义形式在本质上是一样的。它的含义是:const修饰的类型为TYPE的变量value是不可变的。

     TYPE const ValueName = value;
         const TYPE ValueName = value;


    (2)将const改为外部连接,作用于扩大至全局,编译时会分配内存,并且可以不进行初始化,仅仅作为声明,编译器认为在程序其他地方进行了定义.

         extend const int ValueName = value;

    2、指使用CONST
    (1)指针本身是常量不可变
         char* const pContent;

    (2)指针所指向的内容是常量不可变
         const char *pContent;

    (3)两者都不可变
          const char* const pContent;

    (4)还有其中区别方法,沿着*号划一条线:
    如果const位于*的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;
    如果const位于*的右侧,const就是修饰指针本身,即指针本身是常量。

     

    3、函数中使用CONST

    (1)const修饰函数参数
    a.传递过来的参数在函数内不可以改变(无意义,因为Var本身就是形参)

    void function(const int Var);

    b.参数指针所指内容为常量不可变

    void function(const char* Var);

    c.参数指针本身为常量不可变(也无意义,因为char* Var也是形参)

    void function(char* const Var);

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

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

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

    这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的,他禁止对引用的对象的一切修改,唯一不同的是按值传递会先建立一个类对象的副本, 然后传递过去,而它直接传递地址,所以这种传递比按值传递更有效.另外只有引用的const传递可以传递一个临时对象,因为临时对象都是const属性, 且是不可见的,他短时间存在一个局部域中,所以不能使用指针,只有引用的const传递能够捕捉到这个家伙.


    (2)const 修饰函数返回值
        const修饰函数返回值其实用的并不是很多,它的含义和const修饰普通变量以及指针的含义基本相同。
        a.const int fun1() //这个其实无意义,因为参数返回本身就是赋值。
        b. const int * fun2() //调用时 const int *pValue = fun2();
                              //我们可以把fun2()看作成一个变量,即指针内容不可变。
        c.int* const fun3()   //调用时 int * const pValue = fun2();
                              //我们可以把fun2()看作成一个变量,即指针本身不可变。

    一般情况下,函数的返回值为某个对象时,如果将其声明为const时,多用于操作符的重载。通常,不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下:如果返回值为某个对象为const(const A test = A 实例)或某个对象的引用为const(const A& test = A实例) ,则返回值具有const属性,则返回实例只能访问类A中的公有(保护)数据成员和const成员函数,并且不允许对其进行赋值操作,这在一般情况下很少用到。


    4、类相关CONST

    (1)const修饰成员变量
    const修饰类的成员函数,表示成员常量,不能被修改,同时它只能在初始化列表中赋值。
        class A
        {
            …
            const int nValue;        
    //成员常量不能被修改
            …
            A(int x): nValue(x) { } ;
    //只能在初始化列表中赋值
         }
     


    (2)const修饰成员函数
    const修饰类的成员函数,则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。
        class A
        {
            …

           void function()const; //常成员函数, 它不改变对象的成员变量.                        

    //也不能调用类中任何非const成员函数。
    }

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

    a. const成员函数不被允许修改它所在对象的任何一个数据成员。

    b. const成员函数能够访问对象的const成员,而其他成员函数不可以。

     

    (3)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(); 正确

     

    三、将Const类型转化为非Const类型的方法

     

    采用const_cast 进行转换。 
    用法:const_cast <type_id>  (expression)
    该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外, type_id和expression的类型是一样的。

    ·             常量指针被转化成非常量指针,并且仍然指向原来的对象;

    ·             常量引用被转换成非常量引用,并且仍然指向原来的对象;

    ·             常量对象被转换成非常量对象。

     

    四、使用const的一些建议
     

    ·             要大胆的使用const,这将给你带来无尽的益处,但前提是你必须搞清楚原委;

    ·             要避免最一般的赋值操作错误,如将const变量赋值,具体可见思考题;

    ·             在参数中使用const应该使用引用或指针,而不是一般的对象实例,原因同上;

    ·             const在成员函数中的三种用法(参数、返回值、函数)要很好的使用;

    ·             不要轻易的将函数的返回值类型定为const;

    ·             除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

    ·             任何不会修改数据成员的函数都应该声明为const 类型。

     

    五、补充重要说明

     

    ·             类内部的常量限制:使用这种类内部的初始化语法的时候,常量必须是被一个常量表达式

    初始化的整型或枚举类型,而且必须是static和const形式。

    ·             如何初始化类内部的常量:一种方法就是static 和 const 并用,在外部初始化,例如:

    class A { public: A() {} private: static const int i; file://注意必须是静态的! };

    const int A::i=3;另一个很常见的方法就是初始化列表: class A { public: A(int

    i=0):test(i) {} private: const int i; }; 还有一种方式就是在外部初始化,

    ·             如果在非const成员函数中,this指针只是一个类类型的;如果在const成员函数中,

    this指针是一个const类类型的;如果在volatile成员函数中,this指针就是一个

    volatile类类型的。

    ·             new返回的指针必须是const类型的。

    展开全文
  • const参数,const返回值与const函数

    千次阅读 2014-11-12 18:14:17
    在C++程序中,经常用const 来限制对一个对象的操作,例如,将一个变量定义为const 的:  const int n=3; 则这个变量的值不能被修改,即不能对变量赋值。  const 这个关键字经常出现在函数的定义中,而且...
  • const的用法,特别是用在函数后面  在普通的非 const成员函数中,this的类型是一个指向类类型的 const指针。可以改变this所指向的值,但不能改变 this所保存的地址。  在const成员函数中,this的类型是一...
  • 前言本来很清晰的const使用,结果因为二级、三级指针的加入导致思绪变得混乱不堪,于是决定测试一下,把这一块彻底搞清楚…
  • const T、const T*、T *constconst T&、const T*& 的区别

    万次阅读 多人点赞 2015-05-09 12:35:55
    这里的T指的是一种数据类型,可以是int、long、doule等基本数据类型,也可以是自己类型的类型class。单独的一个const你肯定知道指的是一个常量,但const与...const T、const T*、T *constconst T&、const T*& 的区别
  • const int a =1 / int const a=1变量a的值不能改变const int *a=&amp;b指针变量a指向的值不能改变int * const a=&amp;b指针的指向不能改变int const *const a=&amp;b指针指向不能改变,指向的值也不能...
  • const定义的对象属性是否可以改变

    万次阅读 2018-07-09 10:50:02
    在作业盒子面试的时候问到了一个问题,const定义的对象属性是否可以改变。当时没有考虑就回答了不可以,面试官微笑着回答说错了。回来后查看了一下const的定义,明白了其中的原理。 const是用来定义常量的,而且...
  • const char*,char *const,const char*const

    千次阅读 2014-09-15 10:34:35
    const
  • const浅析

    2018-12-13 13:59:57
    前言 c++中使用到const的地方有很多, 而且const 本身也针对不同的类型可能有不同的...const修饰的对象一旦创建一般就不能改变, 所以对于const对象必须进行初始化. int i = 0; const int j; // error. 必须进行初始...
  • 一旦声明,常量的值就不能改变。 只声明不赋值,就会报错。 const命令声明的常量也是不提升,同样存在暂时性死区,只能在声明的位置后面使用 const实际上保证的,并不是变量的值不得改动,而是变量指向的那个内存...
  • 前言:const关键字在C语言里面的作用好像并不大,顶多算个“跑龙套”?但是这个const到了C++里面,可谓是有着不可撼动的地位,关于const在C++里是如何有着不可撼动的地位,接下来我将会进行详细介绍。
  • 今天偶然看到内联汇编,里面有一个const和volatile的部分, 所以想写一个文章...从这里可以看出,这个地址没变,但是他的值确实是改变过, 同样的 ,const 指针 ,const 数组指针 都可以通过加一层指针来改变其数值。
  • 教你改变const变量的值

    千次阅读 2013-01-28 22:42:32
    不过要说明下,用const修饰的变量(这是一个假常量),本质上其实和未用const修饰的变量是没有差别的 用const修饰变量后,只是编译器会检查是否对该变量进行了写操作,若检查出则会报错 代码如下: #include ...
  • const char * 、char const *、 char * const 三者的区别

    万次阅读 多人点赞 2018-06-23 12:46:23
    const char *ptr; char const *ptr; char * const ptr; 现整理三者之间的区别与联系。 一、const char *ptr; 定义一个指向字符常量的指针,这里,ptr是一个指向 char* 类型的常量,所以不能用ptr来修改所指向...
  • 关于const变量的改变

    2012-05-11 11:00:35
    const int a = 0; int *p =(int *)&a; *p = 1; VC下输出a的值还是0,但是内存单元中已经是1; linux下a输出是1; 请各位前辈指点。
  • const对象const成员函数

    2013-09-11 12:40:40
    ... 如果你想定义一个永远都不会改变的类对象,可以像下面这样定义一个const对象 const CBox standard(10.0,10.0,10.0); standard对象的成员变量的值将永不会改变。编译器为了保证const对象
  • const指针指向的地址不可以改变,指向地址的内容是可以改变的。因为const只是保证对象的指针不改变,而对象的内容改变不会影响到指针的改变,所以对象的属性内容是可以修改的。 1、修改对象的属性值是允许的 2、...
  • const char *p1—不可以改变值 char *const p1—不可以改变p指向的地址 const char *const p1—都不可以改变 const char *p1#include #include using namespace std;int main() { char i='x';
  • c++ const对象和const函数

    千次阅读 多人点赞 2018-09-09 20:46:44
    关于const对象和const函数的分析 基本知识: 1.如果一个成员函数不对对象的任何成员数据的进行修改(最常见的为打印成员信息的函数),那么我们可以将这个成员函数设置为const函数,以保护对象数据。如void print()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407,944
精华内容 163,177
关键字:

const怎么改变