深入分析C++引用

背景

在 c/c++ 中，访问一个变量只能通过两种方式被访问，传递，或者查询。这两种方式是：

1. 通过值 访问 / 传递变量

2. 通过地址 访问 / 传递变量 – 这种方法就是指针
      除此之外没有第三种访问和传递变量值的方法。引用变量也就是个指针变量，它也拥有内存空间。最关键的是引用是一种会被编译器自动解引用的指针。很难相信么？让我们来看看吧。。。

下面是一段使用引用的简单 c++ 代码


int
 main()  

{  
    int i = 10;  
// A simple integer variable


int &j = i;  


// A Reference to the variable i


    j++;   // Incrementing j will increment both i and j.
    // check by printing values of i and j
    cout<<  i  <<  j  <<endl; // should print 11
    // Now try to print the address of both variables i and j
  


    cout<<  &i  <<  &j  <<endl;  
    // surprisingly both print the same address and make us feel that they are

    // alias to the same memory location.
  
    // In example below we will see what is the reality

    return 0; 
}   
引用其实就是c++ 中的常量指针。表达式   int&i = j; 将会被编译器转化成 int *consti =&j; 而引用之所以要初始化是因为 const 类型变量必须初始化，这个指针也必须有所指。下面我们再次聚焦到上面这段代码，并使用编译器的那套语法将引用替换掉。


int
 main()  

{  
    int i = 10;         
// A simple integer variable

    int * const j = &i;    
// A Reference to the variable i

    (*j)++;                // Incrementing j. Since reference variables are 
 

                          // automatically dereferenced by compiler

    // check by printing values of i and j
  


    cout<<  i  <<  *j  <<endl; // should print 11 11

    // A * is appended before j because it used to be reference variable


    // and it should get automatically dereferenced.
  

    return 0; 
}  
     读者一定很奇怪为什么我上面这段代码会跳过打印地址这步。这里需要一些解释。因为引用变量时会被编译器自动解引用的，那么一个诸如cout<< &j <<endl; 的语句，编译器就会将其转化成语句   cout<< &*j <<endl;   现在 &* 会相互抵消，这句话变的毫无意义，而 cout 打印的 j 值就是 i 的地址，因为其定义语句为 int*const j = &i;所以语句cout<< &i << &j <<endl; 变成了 cout << &i<< &*j << endl; 这两种情况都是打印输出 i 的地址。这就是当我们打印普通变量和引用变量的时候会输出相同地址的原因。


下面给出一段复杂一些的代码，来看看引用在级联 (cascading) 中是如何运作的。

int
 main()  

{  
    int i = 10; 
// A Simple Integer variable


    int &j = i; 
// A Reference to the variable

    // Now we can also create a reference to reference variable. 
  
    int &k = j; 
// A reference to a reference variable


    // Similarly we can also create another reference to the reference variable k
 
    int &l = k; 
// A reference to a reference to a reference variable.

    // Now if we increment any one of them the effect will be visible on all the

    // variables.

    // First print original values

    // The print should be 10,10,10,10
  
    cout<<  i  <<  ","<<  j  << ","<<  k  << ","<<  l  <<endl; 
    // increment variable j
 
    j++;   
    // The print should be 11,11,11,11
 
    cout<<  i  <<  ","<<  j  << ","<<  k  << ","<<  l  <<endl; 
    // increment variable k

    k++;  
    // The print should be 12,12,12,12
  
    cout<<  i  <<  ","<<  j  << ","<<  k  <<","<<  l  <<endl; 
    // increment variable l 
    l++;  
    // The print should be 13,13,13,13  
    cout<<  i  <<  ","<<  j  << ","<<  k  << ","<<  l  <<endl; 
    return 0; 
}  
 
下面这段代码是将上面代码中的引用替换之后代码，也就是说明我们不依赖编译器的自动替换功能，手动进行替换也能达到相同的目标。

int
 main()  


{  
    int i = 10;       
// A Simple Integer variable

    int * const  j = &i;    
// A Reference to the variable


    // The variable j will hold the address of i
  

    // Now we can also create a reference to reference variable. 

    int * const k = &*j;    
// A reference to a reference variable


    // The variable k will also hold the address of i because j  is a reference variable and  it gets auto dereferenced. After & and * cancels each other k will hold the value of   j which it nothing but address of i  Similarly we can also create another reference to the reference variable k 
    int * const  l = &*k;    
// A reference to a reference to a reference variable.


    // The variable l will also hold address of i because k holds address of i after

    // & and * cancels each other. 
   // so we have seen that all the reference variable will actually holds the same
 


    // variable address.
 

    // Now if we increment any one of them the effect will be visible on all the
 

    // variables.
  

   // First print original values. The reference variables will have * prefixed because 


    // these variables gets automatically dereferenced.
  


    // The print should be 10,10,10,10
 


    cout<<  i  <<  ","<<  *j  << ","<<  *k  << ","<<  *l  <<endl; 
    // increment variable j
 

    (*j)++;   
    // The print should be 11,11,11,11
 
    cout<<  i  <<  ","<<  *j  << ","<<  *k  << ","<<  *l  <<endl; 
    // increment variable k
 


    (*k)++;  
    // The print should be 12,12,12,12
  

    cout<<  i  <<  "," <<  *j  << ","<<  *k  << ","<<  *l  <<endl; 
    // increment variable l
 

    (*l)++;  
    // The print should be 13,13,13,13
 

    cout  <<  i  <<  ","<<  *j  << ","<<  *k  << ","<<  *l  <<endl; 
    return 0; 
}  
我们通过下面代码可以证明


 c++ 的引用不是神马别名，它也会占用内存空间的。

class Test 
{  
    int &i;  
// int *const i;

    int &j;  

// int *const j;

  int &k;   


// int *const k;


};  
int
 main()  


{      
    // This will print 12 i.e. size of 3 pointers
 

    cout<<  "size of class Test = " << sizeof
(


class


 Test)  <<endl; 


    return 0; 
}  

结论

我希望这篇文章能把 c++ 引用的所有东东都解释清楚，然而我要指出的是 c++ 标准并没有解释编译器如何实现引用的行为。所以实现取决于编译器，而大多数情况下就是将其实现为一个 const 指针

 


引用支持c++ 虚函数机制的代码

class A 
{  
​public: 
         virtual void print() { cout<<"A.."<<endl; } 
};  
class B : public A  
{  
public:  
         virtual void 
print() { cout<<"B.."<<endl; } 


};  
   
class C : public B  
{  
public:  
         virtual void print() { cout<<"C.."<<endl; } 
};  
int
 main()  


{  
         C c1;  
         A &a1 = c1;  
         a1.print(); // prints C
         A a2 = c1;  
         a2.print(); // prints A
         return 0; 
}  
 上述代码使用引用支持虚函数机制。如果引用仅仅是一个别名，那如何实现虚函数机制，而虚函数机制所需要的动态信息只能通过指针才能实现，所以更加说明引用其实就是一个const 指针。