精华内容
下载资源
问答
  • 关于C++ const 的全面总结

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

    展开全文
  • C++ const

    2014-01-16 18:20:11
    1. 在C++const对象默认为文件的局部变量(作用域是文件局部变量),通过指定const变量为extern,就可以在整个程序中访问const变量 未添加extern,以下程序链接出错 //var.cpp const int MAX = 100; //var.h ...

    1. 在C++中const对象默认为文件的局部变量(作用域是文件局部变量),通过指定const变量为extern,就可以在整个程序中访问const变量


    未添加extern,以下程序链接出错

    //var.cpp
    const int MAX = 100;

    //var.h
    extern int MAX;
    

    #include <iostream>
    using namespace std;
    
    #include "var.h"
    
    int main()
    {
        int x = MAX;
        cout << "x = " << x << endl;
        return 0;
    }

    error:

    g++ -o main main.cpp var.cpp
    /tmp/cc2YqVv9.o: In function `main':
    main.cpp:(.text+0xa): undefined reference to `MAX'
    collect2: ld returned 1 exit status
    make: *** [main] Error 1


    添加extern,以下程序编译OK

    //var.cpp
    extern const int MAX = 100;

    //var.h
    extern int MAX;
    

    #include <iostream>
    using namespace std;
    
    #include "var.h"
    
    int main()
    {
        int x = MAX;
        cout << "x = " << x << endl;
        return 0;
    }





    展开全文
  • C++ const 修饰符

    千次阅读 多人点赞 2021-05-04 12:17:03
    C++ const 修饰符是什么, const 修饰符的用途以及规范.

    概述

    const 是 constant 的缩写, 是不变的意思. 在 C++ 中是用来修饰内置类型变量, 自定义对象, 成员函数, 返回值, 函数参数. const 可以帮我们避免无意之中的错误操作.
    在这里插入图片描述
    使用 const, 把有关的数据定义为常量 (常变量 / 常对象 / 常函数). const 既可以使数据在一定范围内共享, 又要保证它不被任意修改.

    const 包括:

    • 常对象
    • 常指针
    • 常引用

    常对象

    我们可以将需要保证数据成员不改变的对象, 可以声明为常对象. 常对象中的所有成员的值都不能被修改.

    常变量的两种格式:

    类名 const 对象名[(实参表列)];
    const 类名 对象名[(实参表列)];
    

    常对象必须要有初始值. 例如:

    Time const t1(12, 34, 46);
    const Time t1(12, 34, 46);
    

    试图改变常对象的成员值会发生什么:

    int main() {
    
        const Time t1(10, 10, 10);  // 定义const Time对象
        t1.set_time(2,2,2);  // 试图改变t1对象的成员数据, 报错
    
        return 0;
    }
    
    输出:
    C:\Users\Windows\CLionProjects\Project1\main.cpp: In function 'int main()':
    C:\Users\Windows\CLionProjects\Project1\main.cpp:10:22: error: passing 'const Time' as 'this' argument discards qualifiers [-fpermissive]
         t1.set_time(2,2,2);
                          ^
    In file included from C:\Users\Windows\CLionProjects\Project1\main.cpp:2:
    C:\Users\Windows\CLionProjects\Project1\Time.h:12:10: note:   in call to 'void Time::set_time(int, int, int)'
         void set_time(int h, int m=0, int s=0);
              ^~~~~~~~
    mingw32-make.exe[3]: *** [CMakeFiles\Project1.dir\build.make:81: CMakeFiles/Project1.dir/main.cpp.obj] Error 1
    mingw32-make.exe[2]: *** [CMakeFiles\Makefile2:94: CMakeFiles/Project1.dir/all] Error 2
    mingw32-make.exe[1]: *** [CMakeFiles\Makefile2:101: CMakeFiles/Project1.dir/rule] Error 2
    mingw32-make.exe: *** [Makefile:136: Project1] Error 2
    

    常对象成员

    常成员函数

    如果我们要引用常对象中的数据成员, 就需要将该成员函数声明为 const 型函数, 即常成员函数. 常成员函数可以访问对象中的数据成员, 但不允许修改常对象中数据成员的值.

    举个栗子:

    Time 类:

    #ifndef PROJECT1_TIME_H
    #define PROJECT1_TIME_H
    
    class Time {
    private:
        int minute;
        int second;
    public:
        int hour;
        Time();  // 默认构造函数
        Time(int h, int m=0, int s=0);  // 有参构造函数
        void set_time(int h, int m=0, int s=0);
        void show_time() const;  // 声明为常成员函数
    };
    
    #endif //PROJECT1_TIME_H
    

    Time.cpp:

    #include "Time.h"
    #include <iostream>
    using namespace std;
    
    // 默认构造函数
    Time::Time() : hour(0), minute(0), second(0) {}
    
    // 有参构造函数
    Time::Time(int h, int m, int s) : hour(h), minute(m), second(s) {}
    
    void Time::set_time(int h, int m, int s) {
        hour = h;
        minute = m;
        second = s;
    }
    
    void Time::show_time() const {
        cout << hour << ":" << minute << ":" << second << endl;
    }
    

    main:

    #include "Time.h"
    #include <iostream>
    using namespace std;
    
    int main() {
    
        const Time t1(10, 10, 10);  // 定义const Time对象
        t1.show_time();  // 调用常成员函数
    
        return 0;
    }
    

    调试输出:

    10:10:10
    

    注: const 是函数类型的一部分, 在声明函数和定义函数时都要有 const 关键字.

    常数据成员

    当我们用关键字 const 来声明常量数据成员, 可以限定其值不能改变.

    Time 类:

    #ifndef PROJECT1_TIME_H
    #define PROJECT1_TIME_H
    
    class Time {
    private:
    
    public:
        const int hour;  // 定义hour为常数据成员
        int minute;
        int second;
    
        Time();  // 默认构造函数
        Time(int h, int m=0, int s=0);  // 有参构造函数
        void set_time(int m=0, int s=0);
        void show_time() const;  // 声明为常成员函数
    };
    
    #endif //PROJECT1_TIME_H
    

    因为 hour 为常数据成员, 所以我们只能通过构造函数的参数初始化表对常数据成员进行初始化.

    // 默认构造函数
    Time::Time() : hour(0), minute(0), second(0) {}
    
    // 有参构造函数
    Time::Time(int h, int m, int s) : hour(h), minute(m), second(s) {}
    

    我们不能再构造函数中用赋值的方法对常数据成员初始化. 例如:

    Time::Time(int h){hour=h;}  // 非法
    

    不能用成员函数改变常数据成员的值. 例如:

    void Time::setHour(int h){hour=h;}  // 非法
    

    数据成员访问限制

    常对象中的成员函数未加 const, 编译系统认为其是非 const 成员函数.
    在这里插入图片描述

    常对象修改的限制

    如果一个对象被声明为常对象, 则不能调用该对象的非 const 型的成员函数, 除了由系统自动调用的隐式的构造函数和析构函数.

    要点:

    • 编辑系统只检查函数的声明, 只要发现调用了常对象的成员函数, 而该函数未被声明为 const, 就报错
    • 防止函数修改常对象中数据成员的值
    • 编译系统对不安全的因素予以拦截, 为我们开发人员省了不少心
    • 用常成员函数引用常变量

    常指针

    将指针变量声明为 const 型, 指针值始终保持为其初始值, 不能改变.

    指向对象的常指针格式:

    类名 *const 变量名;
    Time time1(10, 12, 15), t2;
    Time * const pt = &t1  // pt 是常指针
    pt = &t2; // 将一个指针固定
    

    常见用途: 将一个指针固定地与一个对象联系. 将常指针作为函数的形参, 目的是不允许在函数执行过程中改变指针变量的值.

    void doSomething(Test * const p1){
        p1 -> setX(5);
        p1 -> printxy();
    } 
    

    指向常变量的指针

    定义指向常变量的指针变量的一般形式为:

    const 类名 *变量名 / 类型名 const *变量名;
    

    只有常变量的指针能指向常变量:
    在这里插入图片描述
    指向常变量的指针变量可以指向未被声明为 const 的变量, 但不能通过此指针变量改变该变量的值.
    在这里插入图片描述
    重点:

    • 如果一个变量已被声明为常变量 / 对象. 我们就只能用指向常变量的指针指向他, 而不能用非 const 型的变量 / 对象的指针去指向它.

    指向对象的指针

    定义指向对象的指针变量的一般形式为.

    const 类名 *变量名 / 类名 const *变量名;
    

    举个栗子:
    在这里插入图片描述
    如果一个对象已经被声明为常对象, 我们就只能用指向常对象的指针指向他. 而不能用指向非 const 型变量 / 对象的指针指向他.

    指向常对象的指针变量可以指向未被声明为 const 的对象, 但不能通过此指针来改变该对象的值. 例如:
    在这里插入图片描述

    小结

    指向常对象的指针最常用语函数的形参, 以保护形参指针所指向的对象在函数执行过程中不被修改.

    当我们希望在调用函数时对象的值不被修改, 就应当把形参定义为指向常对象的指针变量. 同时用对象的地址作为实参 (对象可以是 const 或非 const 型).
    在这里插入图片描述
    在这里插入图片描述

    对象的常引用

    一个变量的应用就是变量的别名. 变量名和引用名都指向同一段没存单元.

    函数的形参可以是对象的引用. 如果不希望在函数中修改实参的值, 可以将形参声明为常引用. 例如:

    void fun(Time &t); 
    void fun(const Time &);  // 常引用
    

    我们应该尽量使用常引用作为函数参数, 原因有二:

    1. 既能保证数据安全, 使数据不能被随意修改
    2. 在调用函数时不必建立实参的copy, 可以提高程序运行效率

    总结

    在这里插入图片描述

    展开全文
  • C++ const重载

    2016-03-31 10:51:31
    C++ const重载 const_iterator find(const key_type& _Keyval) const iterator find(const key_type& _Keyval)

    在看STL unordered_map的源码时,看到下面一段代码的时候产生了疑惑:

           iterator find(const key_type& _Keyval)
    		{	// find an element in mutable hash table that matches _Keyval
    		return (lower_bound(_Keyval));
    		}
    
    
    	const_iterator find(const key_type& _Keyval) const
    		{	// find an element in nonmutable hash table that matches _Keyval
    		return (lower_bound(_Keyval));
    		}

    这两个函数都是unordered_map的成员函数,乍一看,其函数名和形参列表都是相同的,只有返回值不同,然后心中升起疑问,这样的重载合法吗?

    仔细看,发现第二个函数后面还有一个 const,然后去网上查了下资料,才知道还有constant重载。

    声明类成员函数时,总有一个我们“看不见”的参数,它就是this指针,const重载的实质是,将this指针声明为了const类型,即上述两个函数的参数表其实还是不一样的。

    下面举个简单的例子来说明:

    class constOverload
    {
    public:
    	int test()
    	{
    		cout << 1 << endl;
    		return 1;
    	};
    	bool test() const
    	{
    		cout << 0 << endl;
    		return false;
    	};
    	constOverload()
    	{
    		test(); //输出1
    		const constOverload* p = this;
    		p->test();//输出0
    	}
    }
    


    展开全文
  • C++ const member function

    千次阅读 2020-01-25 09:51:37
    C++ const member functionconst member function參考連結 const member function 在函數定義後面加上const就成了const member function,它的作用是確保在函數裡面不會有成員變數被意外地修改。在const member ...
  • C++ const 关键字

    2016-12-29 21:39:52
    1.C++ const 关键字1.const关键字必须初始化; 2.类中的const常量和引用必须使用重载函数初始化;2.demo//class 与内存 #include class myclass{ public: myclass(int a,int b):coint(b),myint(a)//使用构造函数...
  • C++ const限定符

    千次阅读 2015-12-23 11:25:02
    C++ const限定符简介
  • C++ const总结

    2013-08-25 17:09:27
    C++ const总结 const int a = 5; 对象a是个int型的const对象 int const b = 5; 跟上面相同,对象b也是个int型的const对象   const double *cptr; cptris a pointer to a double that is const cptr指向的对象是...
  • C和C++ const的声明差异

    2016-03-12 11:36:40
    C和C++ const类型的声明差异
  • C++ const char\*与char\* const

    千次阅读 2017-10-29 15:08:34
    C++ const char*与char* constC++里的const char*和char* const一直很容易混,其实只要理解了const到底修饰的哪个,就会豁然开朗。或者就按书中所写的,倒着读来记忆。 const char *p —> p是一个指针,指向const ...
  • C和C++ const用法的区别

    千次阅读 多人点赞 2018-06-13 14:18:29
    C/C++ const用法的区别 区别一:const定义的常量: const定义的常量: C语言:当修饰一个标识符的时候我们来说,这个标识符依然是一个变量,但是它具有常属性,不能被修改。即它定义的变量叫做常变量 C++...
  • c++ const 转 非const

    千次阅读 2019-08-20 19:57:54
    #include "mainwindow.h" #include <QApplication> #include <QtDebug> void fun(const int * temp) ... int *p = const_cast<...//const 转 非const *p = 22; } int main(in...
  • C++const类型的引用参数

    千次阅读 2019-06-12 20:57:36
    C++const类型的引用参数: 具体作用,假设实参的参数类型与引用参数不匹配,但可以转换为引用类型,程序将创建一个正常类型的临时变量,使用转化后的实参值来初始化它,然后传递一个指向该临时变量的引用。 讲的比较...
  • C++ const函数

    2016-05-11 23:51:44
    1.在C++中,若一个变量声明为const类型,则试图修改该变量的值的操作都被视编译错误。 2. 在C++中,只有被声明为const的成员函数才能被一个const类对象调用。 3.C++const成员函数的访问 1)const成员...
  • C++const成员

    千次阅读 2017-12-01 22:51:10
    1.const数据成员在c++中不允许改变的数据成员,我们将它声明为const成员。 const成员的声明形式是 const+类型+变量名; const成员必须用初始化表的形式进行初始化。 如:class A { public: A(); A(int m,int y)...
  • C++ const引用详解

    千次阅读 2013-12-25 16:39:36
    C++ const引用详解 转自:http://chio.cnblogs.com/ (1) 在实际的程序中,引用主要被用做函数的形式参数--通常将类对象传递给一个函数.引用必须初始化. 但是用对象的地址初始化引用是错误的,我们可以定义一...
  • C++ const关键字的总结

    万次阅读 多人点赞 2018-07-31 01:03:30
    const关键字是c++中一个很重要又很有迷惑性的知识点,这里对其进行一次总结。 const修饰非成员变量  const全局/局部变量  const全局变量 在文件a.cpp中定义了一个全局变量a int a = 1;  在文件test.cpp中...
  • c++ const对象和const函数

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

    千次阅读 2012-04-12 10:38:53
    在这篇文章中,我们将会为大家详细介绍有关C++ const变量的相关内容,希望能帮助大家轻松了解这方面知识。 一、对于基本声明 const int r=100; 标准C++ const变量声明加初始化,因为默认内部连接所以必须被...
  • c++ const函数返回值

    千次阅读 2019-07-23 13:20:30
    c++const可用于修饰方法 1. 第一种情况:const位于方法参数列表后,如 void test() const; 此种情况表明,此方法不会改变调用对象的状态,保证了调用对象的常量性 2. 第二种情况:const 位于返回类型前 此...
  • C++ const 常量

    千次阅读 2016-12-16 10:21:17
    const 常量  定义义后就不能被修改,所以定义时必须初始化:const std::string hi = "hello!"; const 对象作用域 在全局作用域定义的非const对象在整个程序中都可以访问,默认为extern. [code1]const...
  • C++ const型成员函数与 non-const型成员函数 vs2013 报错:限定符(const)被丢失class Test { public: int& get() const { return p; } // 编译器报错:将"int& "类型的引用绑定到“const int”类型的初始值...
  • C++ const 指针与指向const的指针

    千次阅读 2017-12-01 09:50:18
    最近在复习C++,指针这块真的是重难点,很久了也没有去理会,今晚好好总结一下const指针,好久没有写过博客了,记录一下~ const指针的定义:  const指针是指针变量的值一经初始化,就不可以改变指向,初始化是...
  • C++ const详解

    千次阅读 2014-07-28 08:53:57
    看到const关键字,C++程序员首先想到的可能是const常量。这可不是良好的条件反射。如果只知道用const定义常量,那么相当于把火药仅用于制作鞭炮。const更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体...
  • C++ const变量在实际编程中起着非常重要的作用,当我们在声明时,需要对其加初始化,因为默认的内部连接都必须被初始化。   在C++编程语言中,还有很多比较高深的内容值得我们在学习和实践中不断的学习...
  • C++ const解析

    2014-03-31 15:53:56
    const修饰指针的情况,见下式: int b = 500; const int* a = & [1] ...按《Effective c++》的做法,如果const位于星号的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;如果

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,751
精华内容 24,300
关键字:

c++const

c++ 订阅