C++ 当const引用释放到g+中的另一个类型时，为什么内存分配是这样的+；4.7.3

我的编译器是g++4.7.3

long i = 2222;
const long& lref = i;
const int& iref = i;
printf("i=%p lref=%p iref=%p \n", &i , &lref, &iref);

long i = 2222;
const long& lref = i;
const int& iref = i;
printf("i=%p lref=%p iref=%p \n", &i , &lref, &iref);

结果是

i=0xbfd78760 lref=0xbfd78760 iref=0xbfd78764

i=0xbfade768 lref=0xbfade768 iref=0xbfade774 a=0xbfade76c b=0xbfade770

i=0xbfbe3f84 lref=0xbfbe3f84 iref=0xbfbe3f83

为什么

iref

的地址高于

i

我想可能是这样的： 当

const int&

引用

long

时

int temp = i
const int& iref = temp;

==========================================================

代码2

但是当代码像

long i = 2222;
const long& lref = i;
const int& iref = i;
int a = 10;
int b = 10;

printf("i=%p lref=%p iref=%p a=%p b=%p\n", &i , &lref, &iref, &a, &b);

结果是

i=0xbfd78760 lref=0xbfd78760 iref=0xbfd78764

i=0xbfade768 lref=0xbfade768 iref=0xbfade774 a=0xbfade76c b=0xbfade770

i=0xbfbe3f84 lref=0xbfbe3f84 iref=0xbfbe3f83

为什么堆栈中

a

和

b

的地址低于

iref

==========================================================

代码3

当代码像

long i = 2222;
const long& lref = i;
const int& iref = i;
int a = 10;
int b = 10;

printf("i=%p lref=%p iref=%p a=%p b=%p\n", &i , &lref, &iref, &a, &b);

结果是

i=0xbfd78760 lref=0xbfd78760 iref=0xbfd78764

i=0xbfade768 lref=0xbfade768 iref=0xbfade774 a=0xbfade76c b=0xbfade770

i=0xbfbe3f84 lref=0xbfbe3f84 iref=0xbfbe3f83

当

iref

的类型为

char

时，为什么

iref

的地址低于

i

---

谁能告诉我为什么，谢谢

你的直觉是对的，

iref

确实是一个单独的内存位置，分配了一个临时的

内存地址的顺序由编译器决定，显然代码生成是这样对堆栈进行排序的。我不知道为什么g++会这样订购—您可能需要深入研究g++内部文档甚至源代码

但是请记住，在大多数系统上，如果堆栈上的地址较低，则表示堆栈上的值较高，因为堆栈通常向下增长

long i = 2222;
const long& lref = i;

这里，引用类型与对象类型匹配，因此

lref

可以是对

i

的引用。因此，您可以看到这两个地址相同

const int& iref = i;

这里的类型不匹配，因此

iref

不能直接引用

i

。人们可能会认为这是一个错误；但是，该语言存在两个漏洞：

• i

  可以转换为

  int

  类型的临时文件；及
• 常量引用可以引用临时引用（延长临时引用的生存期以匹配引用的生存期）

---

（可能令人惊讶的）结果是，

iref

引用了一个单独的值，与

i

不同的地址这些变量在哪个地址有什么关系？OP是否在编写低级和/或嵌入式代码可能有关。然而，这绝对不是这样做的。理解记忆allocating@CLS这里没有太多重要的事情需要了解。在这里，您还需要了解其他一些关于语言语义的内容。AFAIK编译器不需要按照定义的顺序在堆栈中“分配”局部变量。甚至根本不需要分配它们：它们可以直接放入寄存器，完全优化，等等。因此，对我来说，依赖特定的堆栈内存布局似乎不安全，而且浪费时间。（注意：如果我的直觉是正确的，我想在你的最后一段代码中，

const int&iref=I；

相当于

const char&iref=I；

）？？接下来的两个代码不太符合我的直觉？？这就是我想知道的一个可能的线索是填充：可能是g++通过对元素重新排序来最大化堆栈的使用，从而最小化填充。是的，它可能会释放给编译器。谢谢！