常量定义语句const范文

篇一:《const常量与define宏定义的区别》(1) 编译器处理方式不同define宏是在预处理阶段展开。

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

(2) 类型和安全检查不同define宏没有类型，不做任何类型检查，仅仅是展开。

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

(3) 存储方式不同define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。

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

(4)const 可以节省空间，避免不必要的内存分配。

例如#define PI 14159 //常量宏const doulbe Pi=14159; //此时并未将Pi放入ROM中 ......double i=Pi; //此时为Pi分配内存，以后不再分配！double I=PI; //编译期间进行宏替换，分配内存double j=Pi; //没有内存分配double J=PI; //再进行宏替换，又一次分配内存！const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而 #define定义的常量在内存中有若干个拷贝。

(5) 提高了效率。

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

const 与 #define的比较C++ 语言可以用const来定义常量，也可以用 #define来定义常量。

但是前者比后者有更多的优点（1） const常量有数据类型，而宏常量没有数据类型。

编译器可以对前者进行类型安全检查。

而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。

（2）有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

l 【规则5-2-1】在C++ 程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。

3 常量定义规则l 【规则5-3-1】需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。

为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。

l 【规则5-3-2】如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。

例如const float RADIUS=100;const float DIAMETER=RADIUS * 2;4 类中的常量有时我们希望某些常量只在类中有效。

由于#define定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const修饰数据成员来实现。

const数据成员的确是存在的，但其含义却不是我们所期望的。

const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。

不能在类声明中初始化const数据成员。

以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE的值是什么。

class A{…const int SIZE=100; // 错误，企图在类声明中初始化const数据成员 int array[SIZE]; // 错误，未知的SIZE};const数据成员的初始化只能在类构造函数的初始化表中进行，例如class A{…A(int size); // 构造函数const int SIZE ;};A::A(int size) : SIZE(size) // 构造函数的初始化表{…}A a(100); // 对象 a 的SIZE值为100A b(200); // 对象 b 的SIZE值为200怎样才能建立在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。

例如class A{…enum { SIZE1=100, SIZE2=200}; // 枚举常量int array1[SIZE1];int array2[SIZE2];};枚举常量不会占用对象的存储空间，它们在编译时被全部求值。

枚举常量的缺点是它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=14159）。

sizeof(A)=1200;其中枚举部长空间。

enum EM { SIZE1=100, SIZE2=200}; // 枚举常量 sizeof（EM）=4；篇二:《C++语言中const关键字用法总结》C++语言中const关键字用法总结一、const是什么在 C/C++ 语言中，const关键字是一种修饰符。

所谓“修饰符”，就是在编译器进行编译的过程中，给编译器一些“要求”或“提示”，但修饰符本身，并不产生任何实际代码。

就 const 修饰符而言，它用来告诉编译器，被修饰的这些东西，具有“只读”的特点。

在编译的过程中，一旦我们的代码试图去改变这些东西，编译器就应该给出错误提示。

所以，const修饰符的作用主要是利用编译器帮助我们检查自己代码的正确性。

我们使用const在源码中标示出“不应该改变”的地方，然后利用编译器，帮助我们检查这些地方是否真的没有被改变过。

如果我们不小心去修改了这些地方，编译器就会报错，从而帮助我们纠正错误。

使用 const和不使用const，对于最终编译产生的代码并没有影响。

虽然const对于最终代码没有影响，但是尽可能使用const，将帮助我们避免很多错误，提高程序正确率。

二、const可以修饰哪些对象在上面已经提到过了，const是一种修饰符，那它可以作为哪些对象的修饰符呢？下面列举了一些C/C++中用到const的地方。

1，const变量2，const指针3，const引用4，const类5，类的const成员变量6，类的const成员函数7，const修饰函数的形参与返回值下面我们分别讨论上面几种情况下，const的用法。

三、const与变量当一个变量被const修饰后，具有以下几个特点1）该变量只能读取不能修改。

（编译器进行检查）2）定义时必须初始化。

3）C++中喜欢用const来定义常量，取代原来C风格的预编译指令define。

1 const int var; // Error:常量变量"var"需要初始化设定项2 const int var1=42;3 var1=43; // Error表达式必须是可以修改的左值上面代码中第一行和第三行都有错误，注释便是编译器给出的错误提示。

另外注意，在使用const变量作为数组的下标时，变量的值一定要是一个常量表达式(在编译阶段就能计算得到结果)。

1 const int sz=42;2 int iAr[sz];3 const int sz1=size(); // size()必须是一个返回常量的函数4 int iAr1[sz1];56 int var=42;7 const int sz2=var;8 int iAr2[sz2]; // errorsz2只有运行时才知道值四、const与引用我们知道，引用必须在定义的时候赋值，这样就会所引用的变量绑定在一起并作为它的一个别名，在程序中的其他地方，是不能让引用再与其他对象绑定。

这个特性，让引用看起来就像是const对象一样，一旦定义后将不能更改。

所以并不存在const的引用。

但是我们却可以引用一个const的对象(变量)，我们称之为对常量的引用，与普通的引用不同的时，对常量的引用不能被用作修改它所绑定的对象。

1 const int ci=1024;2 const int &r1=ci;3 r1=42; // Errorr1是对常量的引用4 int & r2=ci; //Error不能将一个非常量引用指向一个常量的对象我们知道，引用的类型必须与其所引用对象的类型一致，如下面的代码double dval=14;int& ri=dval; // Error无法用double类型的值初始化int&类型的引用(非常量限定) 上述代码为何不行？此处ri引用了一个int型的整数。

对于ri的操作数应该是整数运算，但是dval却是一个双精度的浮点数而非整数。

因此为了确保让ri绑定一个整数，编译器把上述代码变成了如下形式double dval=14;int temp=dval;int& ri=temp;其中temp是一个临时变量，而ri绑定了一个临时量，所以当ri改变时，并没有改变davl的值，所以这种引用是无效的。

也许你注意到了，当我们把double变量绑定在一个int&类型上时，编译器提示后有个括号非常量限定。

这说明如果是一个常量的引用，则有可能是通过的，显然下面的代码就没有任何问题double dval=14;const int& ri=dval;因为在这里，ri是一个常量引用，我们并不想通过ri改变dval的值，只要能读到dval 对应的int型的值就行。

五、const与指针我们知道，指针与引用不同，指针本身是一个对象，所以存在常量指针，这种指针在定义并初始化后，便不能再指向其他变量。

用来修饰这种常量指针的const，我们称之为"顶层const"。

与顶层指针对应的是底层指针，这种指针指向一个const修改的对象，这一点上就有点像是常量的引用。

对于指向常量的指针或引用，都有以下规则1）可以将一个非const对象的地址赋给一个指向const对象的指针2）可以将一个非const对象的地址赋给一个指向非const对象的指针3）可以将一个const对象的地址赋给一个指向const对象的指针4）不可以将一个const对象的地址赋给一个指向const对象的指针。

1 int var;2 const int ci=42;34 int *p1=& var;5 int *p2=&ci; // Error,const int* 不能用于初始化int*6 const int *p3=&var; //ok7 const int *p4=&ci; // ok还有一种指向const对象的const指针，这种指针首先表明，本身是一个const指针，一旦初始化后不能指向其他对象；其次，它本身所指向的对象也是一个常量，即不能通过指针修改对象的值。

const int var=42;const int* const p=&var;这里再强调一点，const只是给编译器看的，我们可以很轻松的骗过编译器，并看看编译器都做了什么1 const int var=42;2 int* p=(int*)&var;3 *p=20;4 cout << var << endl; //425 cout << *p << endl; //20我们在代码的第2行，用一个类型转换强制的，把一个非const指针指向了一个const 对象。