定义一个引用会分配内存空间么

[TplayT]

RT,是不是不会分配呀

[TplayT]

[Quote=引用 15 楼 iambic 的回复:]
别名不放在内存里，谁给你记着？
[/Quote]
那叫做别名的这块内存存放的什么.存放的是所引用的对象么

[TplayT]

[Quote=引用 2 楼 fetag 的回复:]
追根究底会，但在代码层可以认为不会，因为引用相当于一个alias...
[/Quote]
追根究底怎么说?

[pengzhixi]

引用本身在编译器的实现和它的定义就是两码事,不过编译器不允许你对它取地址值而已

[TplayT]

[Quote=引用 31 楼 pengzhixi 的回复:]
引用本身在编译器的实现和它的定义就是两码事,不过编译器不允许你对它取地址值而已
[/Quote]
郁闷...貌似都说的不是很清楚.

[zhao1zhong6]

如果分配也就顶多分配几个字节。

[TplayT]

[Quote=引用 33 楼 fyzqzpd 的回复:]
如果分配也就顶多分配几个字节。
[/Quote]
不是问这个

[babelan]

摘自《标准C++宝典》第6章：引用既不是对原对象的拷贝，也不是指向原对象的指针。实际上，编译器把它作为原对象的另外一个名字。...实际变量的地址和它的引用的地址...是完全一样的。

基于以上内容：就引起内存空间分配而言，引用的创建不同于创建实际变量。

[iambic]

不确定的自己试下吧。定义一个包含引用的类，然后sizeof下这个类。

[ForestDB]

个人愚见，看你是指引用本身还是被引用的对象，
如果是被引用的对象，自然会为这个对象分配空间，比如：
int a = 3;
int& ra = a;中的a被引用，a是有空间的，
还有：const int& a = 3;这里的3被引用，也是有空间的。
而引用本身个人认为是没有空间的，只是在编译时期引入一个symbol而已，而最终的asm码是看不到这个变量的。

[ForestDB]

嗯，纠正刚才的发言，好像在gcc的实现中是有分配空间的，有点不解，一下是汇编代码的分析：
（注，在VC中也有类似的实现）

#include <iostream>

using namespace std;

int main()
{
  int a = 3;
  int& ra = a;
  const int& rb = 3;

  int c = a;
  c = ra;
  c = rb;

  return 0;
}

globl main
        .type   main,@function
main:
.LFB1479:
        pushl   %ebp
.LCFI0:
        movl    %esp, %ebp          ;以经过此命令后的ebp作为base
.LCFI1:
        subl    $24, %esp
.LCFI2:
        andl    $-16, %esp
        movl    $0, %eax
        subl    %eax, %esp
        movl    $3, -4(%ebp)        ;这是int a = 3;这句，a在-4（base）的位置上（空间上）
        leal    -4(%ebp), %eax      ;取a的地址
        movl    %eax, -8(%ebp)      ;这是int& ra = a;ra在-8（base）
        movl    $3, -12(%ebp)       ;把一个常量3放置于-12（base）
        leal    -12(%ebp), %eax     ;取3的地址
        movl    %eax, -16(%ebp)     ;这是const int& rb = 3;rb在-16（base）
        movl    -4(%ebp), %eax
        movl    %eax, -20(%ebp)     ;int c = a;c在-20（base）
        movl    -8(%ebp), %eax      ;取ra的值，一个地址
        movl    (%eax), %eax        ;透过这个地址去取值
        movl    %eax, -20(%ebp)     ;c = ra;
        movl    -16(%ebp), %eax     ;同ra
        movl    (%eax), %eax
        movl    %eax, -20(%ebp)     ;c = rb;
        movl    $0, %eax
        leave
        ret

从上可以发现，是有空间分配的，而且是指针的语义。

[passionboy03]

int aaa =9;
int ival=1024;
int &reval=ival;
cout<<reval<<endl;
float s;
cout <<"&ival = " <<&ival<<endl;//0012FF78
cout << "&reval = "<<&reval<<endl;//0012FF7
这样是输出一样，但是还是感觉应该有个地址存放reval 名字，再由reval 这个名字指向上面的地址0012FF78，
如果按照这个理解的话，ival也应该有个存放的地址，再由ival指向0012FF78，大胆猜测一下存放这个名字的空间会不会是虚拟的呢？并没有实际分配空间？
有点晕……

[Quote=引用 13 楼 TplayT 的回复:]
引用 6 楼 waizqfor 的回复:
引用 4 楼 waizqfor 的回复:
引用楼主 TplayT 的帖子:
RT,是不是不会分配呀

当然会啊

我的理解是引用一样的会去申请空间！只是不能被显示的调用它的内存（地址)

#include <iostream>
using namespace std;

int main()
{
int ival=1024;
int &reval=ival;
cout < <reval < <endl;
//既然引用是会分配内存空间，那么这个内存空间的名字应该是引用名reval把
//那为…
[/Quote]

[TplayT]

[Quote=引用 37 楼 ForestDB 的回复:]
个人愚见，看你是指引用本身还是被引用的对象，
如果是被引用的对象，自然会为这个对象分配空间，比如：
int a = 3;
int& ra = a;中的a被引用，a是有空间的，
还有：const int& a = 3;这里的3被引用，也是有空间的。
而引用本身个人认为是没有空间的，只是在编译时期引入一个symbol而已，而最终的asm码是看不到这个变量的。
[/Quote]
兄弟,不懂汇编,但是照你的分析来说,应该是这句话说的对了?

引用会分配内存 ,但是你从代码层面是看不到的.而实际上底层上会弱化为指针来处理了.

[TplayT]

[Quote=引用 35 楼 babelan 的回复:]
摘自《标准C++宝典》第6章：引用既不是对原对象的拷贝，也不是指向原对象的指针。实际上，编译器把它作为原对象的另外一个名字。...实际变量的地址和它的引用的地址...是完全一样的。

基于以上内容：就引起内存空间分配而言，引用的创建不同于创建实际变量。
[/Quote]
大哥说这话貌似没说到点子上呀

[pengzhixi]

说了大部分编译器会将引用弱化为指针来实现, 既然是这样那就肯定要分配内存拉. 不过编译器不允许你取其地址而已.

[xuguod20042576]

引用是不会申请空间的,你只不过是变量的另一个"代称".

[activateMan]

会
定义的那个引用变量需要分配内存空间，如果是临时变量，它会占用栈空间

[TplayT]

引用别人的以及总结:
引用变量还是占用内存的.
1.引用变量做形参时，需要通过堆栈传递参数，自然占用内存
2.引用变量做类的成员时，也要占用内存
3.在函数作用域内，如果定义为局部自动变量，还是要占用内存

#include <iostream>
using namespace std;
class No_Ref
{
public:
    int a;
    No_Ref():a(0){}
};
class Ref
{
public:
    int a;
    int & c;
    Ref():a(0),c(a){}
};

int main()
{
    cout<<"类No_Ref大小："<<sizeof(No_Ref)<<endl;
    cout<<"类Ref大小："<<sizeof(Ref)<<endl;
    cout<<"引用变量占用的内存:"<<sizeof(Ref)-sizeof(No_Ref)<<endl;
}

下面的例子是局部变量的例子

#include <iostream>
using  namespace std;

int main()
{
    int i;
    int j;
    int k;
    int &ref = i;
    int t;    
    cout<<&i<<"  "<<&j<<"  "<<&k<<"  "<<&t<<endl;
    //若ref不占用内存，则i,j,k,t,的地址差应该相同
    cout<<"&i-&j="<<sizeof(int)*(&i-&j)
        <<"   &j-&k="<<sizeof(int)*(&j-&k)
        <<"   &k-&t="<<sizeof(int)*(&k-&t)<<endl;
    
    cout<<"引用变量占用的内存:"<<sizeof(int)*(&k-&t)-sizeof(int)*(&j-&k)<<endl;
    return 0;
}

对下面的代码进行反汇编:

int  a = 0xfebc; 
int&  b = a; 

反汇编后得到的代码:

34:        int  a = 0xfebc; 
00401458 C7 45 FC BC FE 00 00 mov        dword ptr [ebp-4],0FEBCh 
35:        int&  b = a; 
0040145F 8D 45 FC            lea        eax,[ebp-4] 
00401462 89 45 F8            mov        dword ptr [ebp-8],eax 

ebp-4为a的空间.
ebp-8为b的空间,存的是a的地址

所以说:引用是会分配内存空间的.
引用的底层实现可能就是通过指针实现的,只是编译器不允许通过cout就cout出引用中的值,而是设计了编译器cout出引用绑定的值
或者可以这么说:引用就是指针,只是这是一个被编译器限制了的指针.我们不能显式得到它所分配的内存空间的值而已.

[疯哥哥]

其实一个引用就是C++对指针的封装,让它用起来更安全.
所以通常是占用空间的.
特别是把引用作为参数的时候,肯定会占用空间.如果加入内嵌汇编的话,使用引用的方法跟指针一样.
除此之外,编译器通常会对引用做优化,可能这种情况下就不会占存储空间了.

[DDGG]

引用其实就是指针，只不过在编译器看起来有不同，且不许你把它当做指针来用。

[TplayT]

[Quote=引用 47 楼 DDGG 的回复:]
引用其实就是指针，只不过在编译器看起来有不同，且不许你把它当做指针来用。
[/Quote]
呵呵,大哥说的极是,谢谢.