【C学习笔记】【疑问】关于const常量的实现机制在C和C++中的不同

【疑问】关于const常量的实现机制在C和C++中的不同

【题目】

int main()

{

  const int a=7;

  int *b=(int *)&a;

  *b=21;

        cout<<"a="<<a<<",*b="<<*b<<endl;

}

【问题】

1，如果按程序所示，用C++中的输出流cout输出a,和*b的值，结果是a=7,*b=21;

  但相同的代码，用C写，用printf()函数输出a,和*b的值，结果却是a=21,*b=21;

  为什么？

2,网上说const的实现机制是在编译的时候，用数值直接替换所有的引用。那为什么不替换*b?只替换a？

【网络解释1】

http://www.2cto.com/kf/200912/43500.html

初探编译器static、const之实现原理

        对于许多C/C++初学者，往往知道static变量只是被初始化一次，对于const变量，只知道他的值是不能被修改的,但是对于其实现却不知所有然。这里我以VC6.0 SP6为平台，揭开其编译器实现原理。
下面看一段程序: 引用:
#include <iostream.h>
void fun(int i)
{
    static int n = i ;
    int *p = &n ;
    cout << n << endl ;
    ++n ;
    //
    // 等下我们要在这写代码，让static int n
    // 每次进这个函数都初始化一次
    //
}
int main(void)
{
    for (int i(10); i > 0; --i)
    {
        fun(i) ;
    }
    return 0;
}程序的输出结果是： 引用:
10
11
12
13
14
15
16
17
18
19下面我们调试一下，看下编译器如何实现:
我们在fun函数的第一行设一个断点。static int n = i ;所在行，按F5。
按Alt+6打开Memory。按F10单步执行，当p有值的时候，我们将他的值拖到Memory窗口，这时就会转到n所在的内存地址,可是这时static已经初始化了,我们不知道编译器对他做了什么操作了。这时我们重新开始调试，一般n的内存地址不会变的，还是在那里。
我这里以我这边的地址为例: 引用:
0042E058 00 00 00 00 ....
0042E05C 00 00 00 00 .... // 中间这个为n的内存地址
0042E060 00 00 00 00 ....我们按F10单步执行一下一条语句(static int n = i ;) 引用:
0042E058 01 00 00 00 ....
0042E05C 0A 00 00 00 ....// n
0042E060 00 00 00 00 ....执行完这条语句之后，除了n有了初值，上面有内存空间也有了变化。
我们接着按F5直接执行到那个断点处，再单步执行一下，发现这次只是n的值有变化，所以我们猜测上面的那个位可能是static的标志位，如果是0的话，说明没有初始化，如果是1的话，说明已经初始化了，下次再进来的时候就不用初始化了，为了验证我们的猜测，我们现在在函数里面加几句语言，修改那个值。 引用:
void fun(int i)
{
    static int n = i ;
    int *p = &n ;
    cout << n << endl ;
    ++n ;
    //
    // 等下我们要在这写代码，让static int n
    // 每次进这个函数都初始化一次
    --p ;
    *p = 0 ;
    //
}写完上面二句，我们执行一下，是不是发现执行结果已经和上面的不同了，每次进函数都会对static int n进行赋初值操作。

下面我们再来看2个static类型的情况，在上面的代码中，我们再加一个 static变量; 引用:
void fun(int i)
{
    static int n1 = i ;
    static int n2 = i ;
    int *p = &n1 ;
    cout << n1 << endl ;
    ++n1 ;
    //
    // 等下我们要在这写代码，让static int n
    // 每次进这个函数都初始化一次
    --p ;
    *p = 0 ;
    //
}还是继续调戏。
二个static变量初始化之前内存里面的值 引用:
0042E050 00 00 00 00 ....
0042E054 00 00 00 00 ....
0042E058 00 00 00 00 ....
0042E05C 00 00 00 00 .... // n1
0042E060 00 00 00 00 .... // n2
0042E064 00 00 00 00 ....当执行完static int n1 = i ;语句之后，内存的值变成这样了 引用:
0042E058 01 00 00 00 ....
0042E05C 0A 00 00 00 ....
0042E060 00 00 00 00 ....接着我们再单步执行
内存的值变成这样。 引用:
0042E058 03 00 00 00 ....
0042E05C 0A 00 00 00 ....
0042E060 0A 00 00 00 ....这样就很明显了，编译器分别用一位来表示一个static变量是否已经始化。

上面是对于用变量对 static进行初始化，对于用常量初始化的情况是怎么样的呢？
我们将上面的代码改成: 引用:
#include <iostream.h>
void fun(int i)
{
    static int n1 = 0x12345678 ;
    int *p = &n1 ;
    cout << *p << endl ;
}
int main(void)
{
    for (int i(10); i > 0; --i)
    {
        fun(i) ;
    }
    return 0;
}当指针取到值之后，我们结束调试。我这里的地址值是0x0042ad64。
好了，我们结束调戏，用winhex打开生成的可执行文件，按Alt+g跳到n的地址，这里要减去0x400000,也就是2ad64。是不是看到我们的初值了。
因为intel使用的是小端法，所以我们看到的值是反过来的。

下面我们再来探索一下const的原理;
下面看一个程序段 引用:
#include <iostream.h>
int main(void)
{
    const int n = 1 ;
    int *p = (int *)&n ;
    *p = 0 ;
    cout << n << endl ;
    cout << *p << endl ;
    return 0;
}我们执行一下，结果是不是和我们所期望的不同呢，我们在第一行下断点，一条一条的执行。
确认每一步操作是否正确。
当执行到*p = 0的时候我们发现n内存所在的值已经变成0了，但是为什么执行结果令我们大失所望呢？
我们按Alt +8打开汇编窗口。 引用:
7:        cout << n << endl ;
0041161E   push        offset @ILT+40(endl) (0040102d)
00411623   push        1
00411625   mov         ecx,offset cout (0042e070)
0041162A   call        ostream::operator<< (004012a0)
0041162F   mov         ecx,eax
00411631   call        @ILT+30(ostream::operator<<) (00401023)
8:        cout << *p << endl ;
00411636   push        offset @ILT+40(endl) (0040102d)
0041163B   mov         edx,dword ptr [ebp-8]
0041163E   mov         eax,dword ptr [edx]
00411640   push        eax
00411641   mov         ecx,offset cout (0042e070)
00411646   call        ostream::operator<< (004012a0)
0041164B   mov         ecx,eax
0041164D   call        @ILT+30(ostream::operator<<) (00401023)原来编译器将我们的const变量直接用常量给替换掉了！
可能有人会想，那这样为什么还要给const变量分配空间呢，这个留给大家思考吧，或者给你们设计编译器的话，你们也会这样实现的！

End

 

 

【网络解释2】

http://www.cppblog.com/xmli/archive/2010/11/23/134425.html

关于常量折叠(转)
首先来看一个例子：

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++》里面说这一点在数组定义里尤其重要(为啥呢？没有查到相关的资料)。