c++ const限定符的使用

const限定符的使用

     

刚写完关于volatile限定符，于是想将const的相关用法一并整理。

=================const 与volatile的关系：==============================

根据c/c++语法，const可以出现的地方，volatile几乎也都可以出现。但是，const修饰的对象其值不能改变，而volatile修饰的对象其值可以随意地改变，也就是说，volatile对象值可能会改变，即使没有任何代码去改变它。在这一点上，最典型的例子就是内存映射的设备寄存器和多线程中的共享对象。懂得使用volatile也是一门小小的艺术。使用volatile约束符可以阻止编译器对代码过分优化防止出现一些你意想不到的情况，达不到预期的结果;过频地使用volatile很可能会增加代码尺寸和降低性能。     

      Dan Saks在其文章中对const的应用做了详细的讲解。

    ===================const关键字的含义===============================

const是只读的。使用const在一定程度上可以提高程序的安全性和可靠性

   ===================const的应用实例=================================

下面的声明都是什么意思？ 

const int a; 
int const a; 
const int *a; 
int * const a; 
int const * a const; 

/******/ 
前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：

   在C中const限定一个变量不允许被改变，即它是只读的。

1.问题：const变量 & 常量（C)

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

　　const int n = 5;

　　int a[n];

　　答案与分析:

　　1）、这个问题讨论的是“常量”与“只读变量”的区别。常量肯定是只读的，例如5， “abc”，等，肯定是只读的，因为常量是被编译器放在内存中的只读区域，当然也就不能够去修改它。而“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。C语言关键字const就是用来限定一个变量不允许被改变的修饰符（Qualifier）。上述代码中变量n被修饰为只读变量，可惜再怎么修饰也不是常量。而ANSI C规定数组定义时维度必须是“常量”，“只读变量”也是不可以的。

　　2)、注意：在ANSI C中，这种写法是错误的，因为数组的大小应该是个常量，而const int n,n只是一个变量（常量 != 不可变的变量，但在标准C++中，这样定义的是一个常量，这种写法是对的），实际上，根据编译过程及内存分配来看，这种用法本来就应该是合理的，只是 ANSI C对数组的规定限制了它。

　　3)、那么，在ANSI C 语言中用什么来定义常量呢？答案是enum类型和#define宏，这两个都可以用来定义常量。
======================C++ const使用:=============================

　　C++中const总结 
一:对于基本声明 
       1.const    int    r=100;    
       //标准const变量声明加初始化,因为默认内部连接所以必须被初始化,其作用域 
       为此文件,编译器经过类型检查后直接用100在编译时替换. 
       2.extend    const    int    r=100;    
       //将const改为外部连接,作用于扩大至全局,编译时会分配内存,并且可以不进行 
       初始化,仅仅作为声明,编译器认为在程序其他地方进行了定义. 
       3.const    int    r[]={1,2,3,4}; 
       struct    S    {int    a,b;}; 
       const    S    s[]={(1,2),(3.4)}; 
       //以上两种都是常量集合,编译器会为其分配内存,所以不能在编译期间使用其中 
       的值,例如:int    temp[r[2]];这样的编译器会报告不能找到常量表达式 
二:对于指针 
       1.const    int    *r=&x;    
       //声明r为一个指向常量的x的指针,r指向的对象不能被修改,但他可以指向任何 
       地址的常量. 
       2.int    const    *r=&x;//与用法1完全等价,没有任何区别。 
       3.int    *    const    r=&x;    
       //声明r为一个常量指针,他指向x,r这个指针的指向不能被修改,但他指向的地址 
       的内容可以修改. 
       4.const    int    *    const    r=&x;    
       //综合1,3用法,r是一个指向常量的常量型指针. 
三:对于类型检查 
       可以把一个非const对象赋给一个指向const的指针,因为有时候我们不想从这个 
       指针来修改其对象的值,但是不可以把一个const对象赋值给一个非const指针, 
       因为这样可能会通过这个指针改变指向对象的值,但也存在使这种操作通过的合 
       法化写法,使用类型强制转换可以通过指针改变const对象： 
       const    int    r=100; 
       int    *ptr=const_cast <int*> (&r);//C++标准,C语言使用:int*    ptr    =(int*)&r;

四:对于字符数组 
       如char    *    name    =    "china ";    
       这样的语句,在编译时是能够通过的,但是 "china "是常量字符数组,任何想修改 
       他的操作也能通过编译但会引起运行时错误,如果我们想修改字符数组的话就要 
       使用char    name[]= "china ";这种形式. 
五:对于函数 
       1.void    Fuction1(const    int    r); 
       //此处为参数传递const值,意义是变量初值不能被函数改变 
       2.const    int    Fuction1(int);    
       //此处返回const值,意思指返回的原函数里的变量的初值不能被修改,但是函数 
       按值返回的这个变量被制成副本,能不能被修改就没有了意义,它可以被赋给任何 
       的const或非const类型变量,完全不需要加上这个const关键字.但这只对于内部 
       类型而言(因为内部类型返回的肯定是一个值,而不会返回一个变量,不会作为左 
       值使用),对于用户自定义类型,返回值是常量是非常重要的,见下面条款3 
       3.Class    CX;    //内部有构造函数,声明如CX(int    r    =0) 
       CX    Fuction1    ()    {    return    CX();    } 
       const    CX    Fuction2    ()    {    return    CX();    } 
       如有上面的自定义类CX,和函数Fuction1()和Fuction2(),我们进行如下操作时: 
       Fuction1()=CX(1);    //没有问题,可以作为左值调用 
       Fuction2()=CX(1);    //编译错误,const返回值禁止作为左值调用.因为左值 
                             把返回值作为变量会修改其返回值,const声明禁止这种修改. 
       4.函数中指针的const传递和返回 
       int    F1    (const    char    *    pstr);    
       //作为传递的时候使用const修饰可以保证不会通过这个指针来修改传递参数的 
       初值,这里在函数内部任何修改*pstr的企图都会引起编译错误. 
const    char*    F2();    
       //意义是函数返回的指针指向的对象是一个const对象,它必须赋给一个同样是指 
       向const对象的指针. 
       const    char*    const    F3();    
       //比上面多了一个const,这个const的意义只是在他被用作左值时有效,它表明这 
       个指针除了指向const对象外,它本身也不能被修改,所以就不能当作左值来处理. 
       5.函数中引用的const传递 
       void    F1    (const    X&    px);    
       //这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的,他禁 
       止对引用的对象的一切修改,唯一不同的是按值传递会先建立一个类对象的副本, 
       然后传递过去,而它直接传递地址,所以这种传递比按值传递更有效. 
       另外只有引用的const传递可以传递一个临时对象,因为临时对象都是const属性, 
       且是不可见的,他短时间存在一个局部域中,所以不能使用指针,只有引用的const 
       传递能够捕捉到这个家伙. 
六:对于类 
       1.首先,对于const的成员变量,只能在构造函数里使用初始化成员列表来初始化, 
       试图在构造函数体内进行初始化const成员变量会引起编译错误.初始化成员列表 
       形如:X::X(int    ir):r(ir){}    //假设r是类X的const成员变量 
       2.const成员函数.提到这个概念首先要谈到const对象,正象内置类型能够定义 
       const对象一样(const    int    r=10;),用户自定义类型也可以定义const对象 
       (const    X    px(10);),编译器要保证这个对象在其生命周期内不能够被改变.如果 
       你定义了这样的一个const对象,那么对于这个对象的一切非const成员函数的调 
       用,编译器为了保证对象的const特性,都会禁止并在编译期间报错.所以如果你想 
       让你的成员函数能够在const对象上进行操作的话,就要把这个函数声明为const 
       成员函数. 
       假如f()是类中的成员函数的话,它的声明形如: 
       int    f()const;    
       //const放在函数的最后,编译器会对这个函数进行检查,在这个 
       函数中的任何试图改变成员变量和调用非const成员函数的操作都被视为非法 
       注意:类的构造和析构函数都不能是const函数. 
       3.建立了一个const成员函数,但仍然想用这个函数改变对象内部的数据.这样的 
       一个要求也会经常遇到,尤其是在一个苛刻的面试考官那里.首先我们要弄清楚考 
       官的要求,因为有两种方法可以实现,如果要求不改变原来类的任何东西,只让你从 
       当前这个const成员函数入手,那么你只有使用前面提到的类型强制转换方法.实例 
       如下: 
       //假如有一个叫做X的类,它有一个int成员变量r,我们需要通过一个const成员函 
       数f()来对这个r进行++r操作,代码如下: 
       void    X::f()const 
       {const_cast <X*> (this)-> ++r;    }    //通过this指针进行类型强制转换实现 
       另外一种方法就是使用关键字:mutable. 
       如果你的成员变量在定义时是这个样子的:mutable    int    r; 
       那么它就告诉编译器这个成员变量可以通过const成员函数改变.编译器就不会再 
       理会对他的检查了