关键词：
const与#define的区别(1) 编译器处理方式不同
define宏是在预处理阶段展开。
const常量是编译运行阶段使用。
(2) 类型和安全检查不同
define宏没有类型，不做任何类型检查，仅仅是展开。
const常量有具体的类型，在编译阶段会执行类型检查。
(3) 存储方式不同
define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。
const常量会在内存中分配(可以是堆中也可以是栈中)。
(4)const 可以节省空间，避免不必要的内存分配。 例如：
#define PI 3.14159 //常量宏
const doulbe Pi=3.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常量完全取代宏常量。
5.3 常量定义规则
l 【规则5-3-1】需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。
l 【规则5-3-2】如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不应给出一些孤立的值。
例如：
const float RADIUS = 100;
const float DIAMETER = RADIUS * 2;
5.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值为100
A b(200); // 对象 b 的SIZE值为200
怎样才能建立在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。例如
class A
…
enum SIZE1 = 100, SIZE2 = 200; // 枚举常量
int array1[SIZE1];
int array2[SIZE2];
;
枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。sizeof(A) = 1200;其中枚举部长空间。
enum EM SIZE1 = 100, SIZE2 = 200; // 枚举常量 sizeof（EM） = 4；
const实现机制
const关键字的基本思想就是将一个变量变成常量，试图从语言设计者的角度去分析引入该关键字的动机。
我猜测原因如下：1）提醒程序员，某些值是常量，如PI。或该值在程序运行期间是不变的，防止程序员误修改。对于多模块开发，头文件引用复杂的系统来说，这是很重要的，如果不能在编译期阻止常量被误修改，那么这些修改将引起运行时调试困难的问题。
2）改进c语言中的#define预处理宏，1）中提到的问题使用#define宏也能够得到解决，但是#define宏作为解决方案存在一些缺陷：a)#define宏会产生二义性。 b)#define宏不支持类型，无法进行类型检测，这对于强类型语言来说，无疑是难以接受的。3）#define宏无法实现后来者const的一些功能。如函数参数传址时，防止被调用函数在调用者不知情的情况下随意修改参数。再如c++类机制中的const成员的访问性控制。
通常的理解，const修饰的变量是不可修改的。其实不然，const关键字在某种程度上来说只是一个面向编译器和程序员的幌子，并不能保证被修饰的内容的不变性。
下面分别按照const的部分用法来分析一下：
1） const修饰局部变量，即声明一个局部常量
int main()
const int con_var1 = 3;
int * b = (int *)&con_var1;
*b = 5;
std::cout <<con_var1 << " "<<*b ;
return 0;
运行结果为3 5。看起来，const确实很负责的保证了被修饰内容的不变性。实际上，这样理解是片面的。const确实在一定程度上使得con_var1变成了一个常量，然而它并没有实现保证con_var1在内存中的值不被修改。
来看一下汇编代码：
Dump of assembler code for function main:
0x080485ce <+0>: push %ebp
0x080485cf <+1>: mov %esp,%ebp
0x080485d1 <+3>: and $0xfffffff0,%esp
0x080485d4 <+6>: push %ebx
0x080485d5 <+7>: sub $0x2c,%esp
<span style="color:#FF0000;">0x080485d8 <+10>: movl $0x3,0x18(%esp)</span>
0x080485e0 <+18>: lea 0x18(%esp),%eax
0x080485e4 <+22>: mov %eax,0x1c(%esp)
0x080485e8 <+26>: mov 0x1c(%esp),%eax
0x080485ec <+30>: movl $0x5,(%eax)
0x080485f2 <+36>: mov 0x1c(%esp),%eax
0x080485f6 <+40>: mov (%eax),%ebx
<span style="color:#FF0000;">0x080485f8 <+42>: movl $0x3,0x4(%esp)</span>
0x08048600 <+50>: movl $0x804a040,(%esp)
0x08048607 <+57>: call 0x8048498 <_ZNSolsEi@plt>
0x0804860c <+62>: movl $0x8048760,0x4(%esp)
0x08048614 <+70>: mov %eax,(%esp)
0x08048617 <+73>: call 0x80484f8 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
0x0804861c <+78>: mov %ebx,0x4(%esp)
0x08048620 <+82>: mov %eax,(%esp)
0x08048623 <+85>: call 0x8048498 <_ZNSolsEi@plt>
0x08048628 <+90>: mov $0x0,%eax
0x0804862d <+95>: add $0x2c,%esp
0x08048630 <+98>: pop %ebx
0x08048631 <+99>: mov %ebp,%esp
0x08048633 <+101>: pop %ebp
0x08048634 <+102>: ret
End of assembler dump. 0x080485d8 <+10>: movl $0x3,0x18(%esp)0x080485e0 <+18>: lea 0x18(%esp),%eax
0x080485e4 <+22>: mov %eax,0x1c(%esp)
0x080485e8 <+26>: mov 0x1c(%esp),%eax
0x080485ec <+30>: movl $0x5,(%eax) 既然内存中的值已经被改成5了，那么为什么最后打印出的值没有改变？
0x080485f8 <+42>: movl $0x3,0x4(%esp)
0x08048600 <+50>: movl $0x804a040,(%esp)
0x08048607 <+57>: call 0x8048498 <_ZNSolsEi@plt> 我们发现，上面同样的行为，使用c将得到不同的结果
int main()
const int con_var1 = 3;
int * b = (int *)&con_var1;
*b = 5;
printf("%d",con_var1);
运行结果输出5， 即con_var1常量被改了！
于是，我猜测以下结论：
a）对于const修饰的局部常量而言，g++编译器（不同编译器机制未必相同）会为其分配内存，由于是静态分配而且是局部常量，所以分配在栈中。
b）对代码中直接引用到该常量（即该常量直接作为右值使用）的情况，编译器会将其直接替换成定义时赋的值。这样一来，无论运行期该常量所在内存被如何修改，都不会影响常量的使用。对于取址操作&con_var而言，&con_var整体被当作一个右值，没有被编译器替换成常值，这也是为什么既然编译器还要为const修饰的常量分配内存的原因。（const folding技术在这里被用到）。
c）const只在编译期间保证常量被使用时的不变性，无法保证运行期间的行为。程序员直接修改常量会得到一个编译错误，但是使用间接指针修改内存，只要符合语法则不会得到任何错误和警告。因为编译器无法得知你是有意还是无意的修改，但是既然定义成const，那么程序员就不应当修改它，不然直接使用变量定义好了。
d）c语言中原本没有const关键字，后来为了兼容，引入了const，但是编译器对其的操作与c++中不同。
2) const修饰 常量指针或指针常量
int main()
int v = 3;
const int * ptr_cvalue = &v;
cout <<v;
cout << *ptr_cvalue;
v = 5;
cout <<v ;
cout<< *ptr_cvalue;
运行结果为5 5,这个结果与const实现这个功能并不冲突，应为const只保证修饰的指针不能被用来修改其指向的内存的值。但是其他手段来修改该内存的值就与const无关了。
这个实验的目的是为了再次说明，const机制并没有在运行期有任何行为，只是编译期的行为。
相类似的，指针本身为常量的也可以通过另一个指向指针的指针来修改其所指向的地址来实现更改。
3）const修饰类成员变量
#include <iostream>
using namespace std;
class A
public:
A(int i=1,int j=2):a(i),b(j)
;
//const int c;
void fun()
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
int *a1 = (int*)&(a);
*a1 = 5;
int *b1 = (int*)&(b);
*b1 = 6;
cout<<&a<<"="<<a<<endl<<a1<<"="<<*a1<<endl;
cout<<&b<<"="<<b<<endl<<b1<<"="<<*b1<<endl;
private:
const int a;
const int b;
;
int main(int argc, char* argv[])
A a;
a.fun();
cout << &a << endl;
return 0;
运行结果为
a=1
b=2
0xbff3b9c8=5
0xbff3b9c8=5
0xbff3b9cc=6
0xbff3b9cc=6
0xbff3b9c8
可以看到，类const成员被修改了。
4）函数const传址也是可以被修改的。
5） const意外的收获---全局常量
#include<iostream>
using namespace std;
const int constant=1;
int main()
unsigned int addr;
int * pconst;
addr=(unsigned int)&constant;
pconst=(int *)addr;
cout<<&constant<<" "<<&addr<<endl;
*pconst=10;//segment fault
cout<<constant<<endl;
return 0;
报段错误，这里报错的原因在于：const int constant,这个全局常量内存分配在.rodata段，对于内存分页机制来说，.rodata对应的页是只读的，当试图去修改该段内存时，会引发段错误，这是在运行期的错误。可以说，这是真正能够保证不会被修改的常量。是在操作系统层面实现的。
总结：const关键字是用于约束程序员和编译器的行为的，而不是程序员用以保证程序正确性的良药，除了全局常量外，没有任何机制保证了const声明的常量的不可修改性，要想使得程序中定义的常量不被修改，就只能循规蹈矩的使用它。
const内存分配：http://blog.chinaunix.net/uid-26983585-id-3301182.html
javascriptes6-let与const使用方及与var对比(代码片段)
ES6语法:let与const本文主要讲解let/const/var关键字相关内容,解释了它们的基本用法以及相关需要注意的知识点;其中还包含一些作用域的相关概念。let/const/var它们的作用基本上是一致的,但是它们还是有很多区别的;下面我们就来看看... 查看详情
面试题：flink反压机制及与sparkstreaming的区别(代码片段)
...rk1.5之后2.2.1、一些相关的参数三、Flink背压机制3.1、背压实现3.1.1、采样线程3.1.2、Sample3.1.3、配置3.2、如何定位背压3.2.1、在web页面发现fink的checkpoint生成超时,失败。3.2.2、查看jobmanager日志3.2.3、BackPressure界面3.2.4、Metrics监控背... 查看详情
面试题：flink反压机制及与sparkstreaming的区别(代码片段)
...rk1.5之后2.2.1、一些相关的参数三、Flink背压机制3.1、背压实现3.1.1、采样线程3.1.2、Sample3.1.3、配置3.2、如何定位背压3.2.1、在web页面发现fink的checkpoint生成超时,失败。3.2.2、查看jobmanager日志3.2.3、BackPressure界面3.2.4、Metrics监控背... 查看详情
const与define的区别
const与#define最大的差别，Const在堆栈分配了空间，而#define只是把具体数值直接传递到目标变量罢了。或者说，const的常量是一个Run-Time的概念，他在程序中确确实实的存在可以被调用、传递。而#define常量则是一个Compile-Time概念，... 查看详情
php常量定义之define与const对比(代码片段)
阅读目录简要归纳PHP中两个常量定义关键字的区别简要归纳PHP中两个常量定义关键字的区别1、define是函数，const是语言结构，PHP编译时const速度快。2、define只能用在类外，const类内类外皆可。3、define定义的常量是全局... 查看详情
php常量定义之define与const对比(代码片段)
阅读目录简要归纳PHP中两个常量定义关键字的区别简要归纳PHP中两个常量定义关键字的区别1、define是函数，const是语言结构，PHP编译时const速度快。2、define只能用在类外，const类内类外皆可。3、define定义的常量是全局... 查看详情
javascriptes6-let与const使用方及与var对比(代码片段)
ES6语法:let与const本文主要讲解let/const/var关键字相关内容,解释了它们的基本用法以及相关需要注意的知识点;其中还包含一些作用域的相关概念。let/const/var它们的作用基本上是一致的,但是它们还是有很多区别的;下面我们就来看看... 查看详情
const和define()的区别
...方法都可以定义常量，使用方法如下 但是他们有什么区别呢1.使用位置不同，const可以在class内使用，class外使用，而define只能在class外使用2.作用范围不同，const会受命名空间影响，define不受命名空间影响，如果const在class内定... 查看详情
宏定义#define和常量const的区别
宏定义#define和常量const的区别类型和安全检查不同宏定义是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边际效应等错误；const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查编译... 查看详情
const和#define有什么区别？
答：（1）const和#define都可以定义常量，但是const用途更广。（2）const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意... 查看详情
const常量与define常量的区别
...可以使用const定义，也可以使用#define宏定义的方式；二者区别如下：-**区别**1.const定义的常量有自己的数据类型，编译器可以对其进行严格的类型检查；但是define定义的宏常量没有数据类型，执行时只会对其进行字符替换，不会... 查看详情
php中const和define的区别
...以后的代码中，我们不允许改变此常量的值。两者之间的区别：内存空间的分配上。define进行宏定义的时候，不会分配内存空间，编译时会在main函数里进行替换，只是单纯的替换，不会进行任何检查,比如类型，语句结构等，即... 查看详情
define和const的区别
常量是一个简单值的标识符（名字）。如同其名称所暗示的，在脚本执行期间该值不能改变（除了所谓的魔术常量，它们其实不是常量）。常量默认为大小写敏感。通常常量标识符总是大写的。 可以用define()函... 查看详情
define和const的区别
常量是一个简单的标识符。在脚本执行期间该值不能改变（除了所谓的魔术常量，他们其实不是常量）。常量默认大小写敏感。通常常量标识符总是大写的。 可以用define()函数来定义常量。在php5.3.0以后，可以使用const关键字... 查看详情
const和define的使用区别
在PHP中(PHP 4及以后)，我们可以使用函数define()来定义常量，例如：<?phpdefine(‘PI‘,3.14159); //定义一个名为PI的常量 echo PI; //输出：3.14159?>不过，在PHP 5.3.0之后，除了使用函数define()之... 查看详情
const和defin区别
（1）类型的安全性检查：const常量有数据类型，而define定义宏常量没有数据类型。则编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查（字符替换时可能会产生意料不到的错误，如上面的程序所... 查看详情
预处理conststatic与sizeof-使用const与#define的特点及区别
1：#define只是用来做文本替换的。例如：#definePI3.1415926floatangle;angle=30*PI/180; 那么，程序进行编译的时候，编译器会首先将“#definePI3.1415926”以后所有代码中的“PI”全部换成“3.1415926”，然后进行编译。因此，#define常量... 查看详情
“static const”、“#define”和“enum”在性能和内存使用方面的区别
...taticconst”、“#define”和“enum”在性能和内存使用方面的区别【英文标题】：Differencebetween“staticconst”,“#define”,and“enum”inperformanceandmemoryusageaspects【发布时间】：2014-01-2317:28:35【问题描述】：由于#define语句的内联，可能存... 查看详情