首先来看一个例子：

int main(int argc, char* argv[])
{
const int i=0;
int *j = (int *) &i;
*j=1;
cout<<&i<<endlcout<<j<<endl;
cout<<i<<endl;
cout<<*j<<endl;
return 0;
}

结果是

0012ff7c
0012ff7c

0

1

因为i和j都指向相同的内存地址，所以输出的前两个结果是相同的，但为啥相同的内存里的结果不相同么？－－这就是常量折叠.

这个"常量折叠"是 就是在编译器进行语法分析的时候，将常量表达式计算求值，并用求得的值来替换表达式，放入常量表。可以算作一种编译优化。
我只是改了这个地址内容,但是i还是0,

因为编译器在优化的过程中，会把碰见的const全部以内容替换掉（跟宏似的: #define pi 3.1415,用到pi时就用3.1415代替），这个出现在预编译阶段；但是在运行阶段，它的内存里存的东西确实改变了!!!

6.网上的一些问题（4）

关于常量

这些天被常量的一些概念折磨着,现在终于有些明白了，

问题始于const int i = 10;//i存在哪，10存在哪

说明一：符号表

这个语句是对i的声明，因为编译器一开始就知道i的值，所以以后出现i时就会用10代替，这好像叫做符号表的概念，i就对应10了。

网上一篇帖子上有这样的代码：

const int a = 3;

int *p = const_cast<int *>(&a);

*p = 4;

cout << a;//仍然输出3

这个结果可以用上面的说明来解释

说明二：常量折叠（const folding）与复写传播 (copy propagation)

网上人们普遍反映thinking in c++将const folding译为常量折叠是种误导，我觉得译的还行，本来folding就有折叠的意思，就是把原来的东西变小，而象const int i = 2*2;编译器确实将2*2算成4了，以后碰到i就用4替换，这个计算2*2的过程据说叫常量折叠--const folding，而用4替换i的过程叫做复写传播--copy propagation.他们都是编译器的优化技术

说明三：为常量分配空间

补充一下，这里说的都是const 定义的常量，而非文字常量，

（c++ primer翻译成文字常量--literal constant

the c++ programming language（tcpl）翻译成文字量，还分了不同类型）

至于文字常量存在哪，c++ primer 3ed上说它们是不可寻址的--nonaddressable，尽管它们也存在机器内存某个地方，但无法访问它们的地址

对于int double等类型还好理解，但是对于字符串常量（tcpl里说将字符串文字量作为常量，利于存储与访问时的优化）下面的代码似乎表示字符串常量存储在静态存储区里（字符串文字量是静态分配的--tcpl），那么字符串常量的地址不是可以访问了吗，在静态存储区里

http://bbs.bc-cn.net/dispbbs.asp?boardid=56&replyi...

字符串文字量的类型是常量字符数组--适当个数的const字符的数组

//有关字符常量的存储区的问题

//另外，char a[]和char *a的区别

//"hello world 1"存在哪
#include <iostream>
using namespace std;
int main()
{

char* p = "hello world1"；
char a[] = "hello world2"；
//会为a在栈上分配13个字节的空间
// p[2] = a;
a[2] = a;
char* p1 = "hello world1"
printf("%xn",&p[2]);//p应该指向常量区
printf("%x",&a[2]);//栈上数组第三个元素的地址
return 0;
//结果42f036 //这是常量区
//12ff6e果然不一样，这是栈区
}

6.总结

那么"常量折叠"到底是啥意思呢？

我理解，简单的说就是，当编译器处理const的时候，编译器会将其变成一个立即数。

《thinking in c++》里面说这一点在数组定义里尤其重要(为啥呢？没有查到相关的资料)。

Technorati : Zoundary, test, 常量折叠

版本：0.1

最后修改：2010-11-22

撰写：李现民

概述

const在c++中意味着“不可改变”，但在有些情况下我们可以“合法”地绕过编译器去修改一些const数据，比如const_cast就可以剥离一个对象的const属性。然而，我们这样做在多大程度上是“合理”的，却因不同的问题而论，也许一不小心，你就可能掉入陷阱之中。

以下问题，我只分析，不说话，请各位看官自己判断。

当目标是一个常数

这件事源于在网上看到的一篇文章，其来源已经不可考，但大意是：就如下C++程序，其输出是什么：

void foo()
{
const int a = 1;
int* p = const_cast<int*>(&a);
*p = 2;
printf(" a= %d\n *p= %d\n &a= %x\n p= %x \n\n", a, *p, &a, p);
}

我在VC2008下的实测结果为：

a = 1
*p = 2
&a = 12ff6c
p = 12ff6c

好了，问题出现：明明p所指向的就是变量a，但为何打印其值时a!=*p？

这并非是我用错了const_cast，也不是编译器进行了优化的问题。事实上，在各版本的VC与g++下的运行结果均是如此。

以下是VC2008下debug版本的汇编代码：

const int a = 1;
0041146E mov dword ptr [a],1
int* p = const_cast<int*>(&a);
00411475 lea eax,[a]
00411478 mov dword ptr [p],eax
*p = 2;
0041147B mov eax,dword ptr [p]
0041147E mov dword ptr [eax],2
printf(" a= %d\n *p= %d\n &a= %x\n p= %x \n\n", a, *p, &a, p);
00411484 mov esi,esp
00411486 mov eax,dword ptr [p]
00411489 push eax
0041148A lea ecx,[a]
0041148D push ecx
0041148E mov edx,dword ptr [p]
00411491 mov eax,dword ptr [edx]
00411493 push eax
00411494 push 1
00411496 push offset string " a=\t%d\n *p=\t%d\n &a=\t%x\n p=\t%x \n\n"... (415808h)
0041149B call dword ptr [__imp__printf (419318h)]

从printf()的四个参数入栈过程中我们可以看出：指针p的确指向变量a了，而变量a处的数值也的确被改写成2了，问题是：当压入a的值的时候，编译器直接压入了其原始数值1。

关键其实在于：const_cast所操作的目标是否为基础数据类型（char, int, float, double等），如果是类（或结构体）对象则又将是另一番情形。

当修改字符串常量

这个问题最早见于一篇文章《Solmyr的小品文系列之一：字符串放在哪里？》，在这里我只不过转述一二。

代码如下：

void foo()
{
char* str1 = "watch";
const char* str2 = "watch";
char str3[] = "watch";

str1[0] = 'm';

std::cout<< str1 << std::endl << str2 << std::endl << str3 << std::endl;
}

VC6中Release版本运行结果如下：

match
match
watch

VC2008中Release版本运行结果如下：

watch
watch
watch

容易看出：这段代码的运行结果决定于编译器，因为我们改写了不应该被改写的常量数据。更根本的原因是：由于编译器优化，str1与str2实际上指向的是同一份”watch”字符串。

这还带出了另一件事：尽管str1的声明中不带const，但它所指向的字符串数据隐含是const类型的。

注意：这段代码只有Release版本才能顺利执行，Debug版版本运行时会得到一个Access violation 。

delete this--对象请求自杀

版本：0.1

最后修改：2009-08-18

撰写：李现民

     第一次见delete this的时候，没觉得这是一项会有什么特殊作用的技术，因此也就没有特别关注。

     昨日在sourcemaking.com上看state模式之c++实现的时候，看到它在状态转换的时候使用了delete this，感觉似乎还不错。

     作为一种“禁术”，使用的时候必须要相当小心才行，《C++ FAQ》里提到所谓“小心”至少包括以下几个方面：

1. this对象是必须是用 new操作符分配的（而不是用new[]，也不是用placement new，也不是局部对象，也不是global对象）；

2. delete this后，不能访问该对象任何的成员变量及虚函数（delete this回收的是数据，这包括对象的数据成员以及vtable，不包括函数代码）；

3. delete this后，不能再访问this指针。换句话说，你不能去检查它、将它和其他指针比较、和 NULL比较、打印它、转换它，以及其它的任何事情；

     个人认为保证以上禁忌列表基本手段可以包括：

1. 将析构函数私有化（如果有子类，则protected化，保证子类能够正确继承）--以保证对象必须使用new在堆上分配内存；

2. 提供（可以在仅仅在基类中）Destroy(void)函数，里面仅有一句delete this--以保证第三方能够将分配的内存回收；

     下一次使用state pattern的时候，我想可以尝试一下。