КД>>union
КД>>{
КД>> long* px;
КД>> long& rx;
КД>> //....
КД>>};
КД>>

- Врешь, однако. Роботы класса "Буратино" нырять не могут.
- Не могут. Но ныряют.

union
{
 long* px;
 long& rx;
 //....
};

P>    int val = 10;
P>    int *p = &val;
P>    // жил был указатель, тут его обнуляем...
P>    p = NULL;
P>    // а здесь получаем ссылку. увы ссылка нулевая и проверить уже никак не можем.
P>    int &ref = *p;// ВОТ ТУТ МЫ ПОЛУЧАЕМ НЕОПРЕДЕЛЕННОЕ ПОВЕДЕНИЕ     
P>    ref++;// А этот код вполне корректен
P>

class A;

void Foo(A& ref)
{
  ref.CallSomeFoo();// Код полностью корректен
};

void Foo(A* ptr)
{
  ptr->CallSomeFoo();// Код не корректен. Получаем интересное поведение при передаче нулевого указателя и по ушам от начальства :maniac: 
}

3 It is unspecified whether or not a reference requires storage (3.7).

Note: a reference can be thought of as a name of an object.

_>        int a = 0;
_>        int &b = a; // b ссылается на a
_>        int c = 1;
    
_>        __asm lea    eax,[c]
_>        __asm mov    dword ptr [b],eax
       
_>        /* теперь b ссылается на c */
_>        b = 2; // c равно 2, а -- 0
        
_>       __asm mov         dword ptr [b], 0
_>       // теперь b равен нулю.

_>

        int volatile a = 10;
0040100C  mov         dword ptr [esp],0Ah 
        int volatile *volatile pa = &a;
00401013  lea         eax,[esp] 
00401016  mov         dword ptr [esp+8],eax 
        int volatile &volatile ra = a;

        int volatile a1 = a;
0040101A  mov         ecx,dword ptr [esp] 
0040101D  mov         dword ptr [esp+4],ecx 
        int volatile a2 = *pa;
00401021  mov         edx,dword ptr [esp+8] 
00401025  mov         eax,dword ptr [edx] 
00401027  mov         dword ptr [esp+4],eax 
        int volatile a3 = ra;
0040102B  mov         ecx,dword ptr [esp] 
0040102E  mov         dword ptr [esp+4],ecx

M>А если ложки не существует, то как она может оказаться в стеке ?

It is unspecified whether or not a reference requires storage. (8.3.2/3)

In some cases, the compiler can optimize away a reference so that there is no object representing that reference at runtime. (5.5 References)

// 1
void Foo( int& result )
{
///.....
}

// 2
void Foo( int* p )
{
 if (!p )return;

 int& ref=*p;
//.....
}

КД>union
КД>{
КД> long* px;
КД> long& rx;
КД> //....
КД>};
КД>

КД>Явно написана грязными извращенцами

class A
{
public:
 // Функция НЕ виртуальная
 void Foo();
};

A* p=0;
p->Foo();

    int val = 10;
    int *p = &val;
    // жил был указатель, тут его обнуляем...
    p = NULL;
    // а здесь получаем ссылку. увы ссылка нулевая и проверить уже никак не можем.
    int &ref = *p;
    
    ref++;

        int a = 0;
        int &b = a; // b ссылается на a
        int c = 1;
    
        __asm lea    eax,[c]
        __asm mov    dword ptr [b],eax
       
        /* теперь b ссылается на c */
        b = 2; // c равно 2, а -- 0
        
       __asm mov         dword ptr [b], 0
       // теперь b равен нулю.

{
 int   x(0);
 int&  rx=x;
 
 //тут память под rx действительно не нужна
 // хотя это зависит от "разумности" компилятора
 rx=::my_func_for_calc_the_x();
}

class TC
{
 public:
  //ссылка x будет занимать место в стековой памяти
  // ... если компилятор не встроит конструктор в точку вызова (я про inline)
  TC(int& x):m_rx(x){;}

 private:
  int& m_rx;//вот тут память под ссылку тоже однозначно будет выделена
};//class TC

CSomeClass & foo( void )
{
    CSomeClass obj;
    return obj;  // <- Здесь не вызовется деструктор объекта obj? Или что я не так понимаю?
}

static int_type increment(volatile int_type& x)

static int_type increment(volatile int_type* x)

> CSomeClass & foo( void )
> {
>    CSomeClass obj;
>    return obj;  // <- Здесь не вызовется деструктор объекта obj? Или что я не так понимаю?
> }
>

CSomeClass foo( void ); //Результат функции - значение (не ссылка).
//...
CSomeClass& t = foo(); //Временный объект, возвращенный функцией будет жить до тех пор, пока жива ссылка
//...

на этапе компиляции компилятор заменяет ссылку нужным именем

// скомпилировано на VC6
#include <windows.h>

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
// Засуньте в Watch g, gl, gh а заодно и  &g, &gl, &gh и многое увидите.
    int g = 0;
    unsigned short &gl = reinterpret_cast<unsigned short *>(&g)[0]; 
    unsigned short &gh = reinterpret_cast<unsigned short *>(&g)[1]; 

    gl++;
    gh++;
    g = ::GetTickCount();
    g /= 3;
    g *= 5;

    return 0;
}

// скомпилировано на VC6
#include <windows.h>

void byref(int &p)
{
    char szMsg[11];

    ::MessageBox(NULL, ::_itoa(p, szMsg, 10), "Reference", MB_OK);
}

void byptr(int *p)
{
    char szMsg[11];
    
    ::MessageBox(NULL, ::_itoa(*p, szMsg, 10), "Pointer", MB_OK);    
}

typedef void (*func)(int *p);

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
    int g = ::GetTickCount();
    func pf;

    pf = byptr;
    (pf)(&g);
    pf = reinterpret_cast<func>(byref);
    (pf)(&g);

    return 0;
}

    int val = 10;
    int *p = &val;
    // Оператор "*" разименования указателя, даёт rvalue, а у rvalue нельзя взять адрес,
    // т.е. низя сделать объект с адресом таким же как у объекта у которого адреса нет,
    // так что IMHO факт того, что такой опенратор скомпилился, является BUG'ом 
    // компилятора, а не языка.
    int &ref = *p;

int main( void )
{
  int * test;
}

int io( 10 );
int & i( io );

#include <iostream>

extern int & i;

int main( void )
{
  ::std::cout << i;
}

struct Pointers{
  int *m1,*m2,*m3,*m4;  
};
struct References{
  int &m1,&m2,&m3,&m4;  
  References();
};
int test[sizeof(References) == sizeof(Pointers)];

class TC
{
 public:
  //ссылка x будет занимать место в стековой памяти
  // ... если компилятор не встроит конструктор в точку вызова (я про inline)
  TC(int& x):m_rx(x){;}

 private:
  int& m_rx;//вот тут память под ссылку тоже однозначно будет выделена
};//class TC

struct    STR{ 
            int    a;
            float  b;
            int&   la=a;
            float& lb=b;
            }

void link_use(int& l1, int& l2, float& l3)
{
  l1 = 100;
  l2 = 200;
  l3 = 0.3;
}

void point_use(int* l1, int* l2, float* l3)
{
  *l1 = 1000;
  *l2 = 2000;
  *l3 = 0.03;
}

void noret_use(int l1, int l2, float l3)
{
  l1 = 100;
  l2 = 200;
  l3 = 0.3;
}

int _tmain(int argc, _TCHAR* argv[])
{   
     int i1=0, 
         i2=0;
  float  i3=0;
  float& l3=i3;
  const  int& li2 = 10;
    
  link_use(i1, i2, i3);
  point_use(&i1, &i2, &i3);
  noret_use(i1, i2, i3);

  return 0;
}

--- c:\documents and settings\aan\my documents\visual studio 2005\projects\links\links\links.cpp 

int _tmain(int argc, _TCHAR* argv[])
{   
1  004135E0  push        ebp  
2  004135E1  mov         ebp,esp 
3  004135E3  sub         esp,108h 
4  004135E9  push        ebx  
5  004135EA  push        esi  
6  004135EB  push        edi  
7  004135EC  lea         edi,[ebp-108h] 
8  004135F2  mov         ecx,42h 
9  004135F7  mov         eax,0CCCCCCCCh 
10 004135FC  rep stos    dword ptr es:[edi] 

    int i1=0, 

11 004135FE  mov         dword ptr [i1],0 

        i2=0;

12 00413605  mov         dword ptr [i2],0 

    float i3=0;

13 0041360C  fldz             
14 0041360E  fstp        dword ptr [i3] 

    float& l3=i3;

15 00413611  lea         eax,[i3] 
16 00413614  mov         dword ptr [l3],eax 

    const int& li2 = 10;

17 00413617  mov         dword ptr [ebp-44h],0Ah 
18 0041361E  lea         eax,[ebp-44h] 
19 00413621  mov         dword ptr [li2],eax 
    
    link_use(i1, i2, i3);

20 00413624  lea         eax,[i3] 
21 00413627  push        eax  
22 00413628  lea         ecx,[i2] 
23 0041362B  push        ecx  
24 0041362C  lea         edx,[i1] 
25 0041362F  push        edx  
26 00413630  call        link_use (411118h) 
27 00413635  add         esp,0Ch 

    point_use(&i1, &i2, &i3);

28 00413638  lea         eax,[i3] 
29 0041363B  push        eax  
30 0041363C  lea         ecx,[i2] 
31 0041363F  push        ecx  
32 00413640  lea         edx,[i1] 
33 00413643  push        edx  
34 00413644  call        point_use (4111C7h) 
35 00413649  add         esp,0Ch 

    noret_use(i1, i2, i3);

36 0041364C  push        ecx  
37 0041364D  fld         dword ptr [i3] 
38 00413650  fstp        dword ptr [esp] 
39 00413653  mov         eax,dword ptr [i2] 
40 00413656  push        eax  
41 00413657  mov         ecx,dword ptr [i1] 
42 0041365A  push        ecx  
43 00 41365B  call        noret_use (4111CCh) 
44 00413660  add         esp,0Ch 

    return 0;

45 00413663  xor         eax,eax 
}

S>class TC
S>{
S> public:
S>  //ссылка x будет занимать место в стековой памяти
S>  // ... если компилятор не встроит конструктор в точку вызова (я про inline)
S>  TC(int& x):m_rx(x){;}

S> private:
S>  int& m_rx;//вот тут память под ссылку тоже однозначно будет выделена
S>};//class TC

S>struct    STR{ 
S>            int    a;
S>            float  b;
S>            int&   la=a;
S>            float& lb=b;
S>            }

struct    STR{ 
            int    a;
            float  b;
            int*   la=&a;
            float* lb=&b;
            }

struct    STR{ 
            int    a;
            float  b;
            int*   la=0;
            float* lb=0;
            }

S>struct    STR{ 
S>            int    a;
S>            float  b;
S>            int&   la=a;
S>            float& lb=b;
S>            }

struct    STR{ 
            int    a;
            float  b;
            int&   la;
            float& lb;
            STR() : la(a), lb(b) {}
            };