C++ 引用、const指针

最新推荐文章于 2023-02-14 16:43:49 发布

leijunan

最新推荐文章于 2023-02-14 16:43:49 发布

阅读量561

点赞数

分类专栏： C++

C++ 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

转自： http://blog.csdn.net/webscaler/article/details/6577429

关于引用和指针的区别的文章很多很多，但是总是找不到他们的根本区别，偶然在codeproject上看到这篇文章，觉得讲的挺好的，

所以翻译了下，希望对大家有帮助。

原文地址: http://www.codeproject.com/KB/cpp/References_in_c__.aspx

引言

我选择写C++中的引用是因为我感觉大多数人误解了引用。而我之所以有这个感受是因为我主持过很多C++的面试，并且我很少从面试者中得到关于C++引用的正确答案。

那么c++中引用到底意味这什么呢？通常一个引用让人想到是一个引用的变量的别名，而我讨厌将c++中引用定义为变量的别名。这篇文章中，我将尽量解释清楚，c++中根本就没有什么叫做别名的东东。

背景

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

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

2.通过地址访问/传递变量 – 这种方法就是指针

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

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

    #include <iostream.h>  
    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 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 *const i = &j; 而引用之所以要初始化是因为const类型变量必须初始化，这个指针也必须有所指。下面我们再次聚焦到上面这段代码，并使用编译器的那套语法将引用替换掉。

    #include <iostream.h>  
    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 *constj = &i;

所以语句cout << &i << &j << endl; 变成了 cout << &i << &*j << endl; 这两种情况都是打印输出i的地址。这就是当我们打印普通变量和引用变量的时候会输出相同地址的原因。

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

    #include <iostream.h>  
    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;  
    }

下面这段代码是将上面代码中的引用替换之后代码，也就是说明我们不依赖编译器的自动替换功能，手动进行替换也能达到相同的目标。

    #include <iostream.h>  
    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++的引用不是神马别名，它也会占用内存空间的。

    #include <iostream.h>  
    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++虚函数机制的代码

    #include <iostream.h>  
    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指针。

初始化 const 成员和引用类型成员

文章来源： http://liouwei20051000285.blog.163.com/blog/static/252367420111165228536/

初始化 const 成员和引用类型成员的问题，在 C++ 教材中讲述初始化列表的章节应该都有讲过，但是因为平时用得少，所以可能有不少人没注意到。待到用时又觉得一头雾水，摸不着头脑。

　　初始化 static const 成员，也就是全局的静态常量，这个用到的情况比较多，想必大家都会。通常就是在类的定义中申明 static const 成员，然后在实现文件中赋予初始值，比如：

/* (#) Test.h */
#pragma once

class Test {
public:
// 申明int 型的MASK 常量
static const int MASK;
};

/* (#) Test.cpp */
#include "Test.h"

// 定义Test::MASK 常量，注意这里不需要static 关键字
const int Test::MASK = 0xFFFF;

虽然这种 static const 的情况使用得最多，但有时候也会想用非 static，却是 const 的情况。static const 定义的常量是全局的，对该类的每一个实例（对象）甚至在全局范围都有效，而且一致。便有时候需要的常量是针对每一个实例的，每个实例都可能有同类型但不同值的常量，这时候就要用到非 static，但 const 的申明，如

class Test {
public:
const int MY_MASK;
};

这种情况下，要在实例文件中像初始化 static const 常量一样，对其进行初始化是行不通的。
const int Test::MY_MASK = 0xFF; // 这样会报重定义错误

　　况且，就算编译能通过，也不能达到我们要求的“每个对象自己的常量”的要求。
　　正确的初始化是通过构造函数的初始化列表来进行，如：

class Test {
public:
const int MY_MASK;
Test() : MY_MASK(0xff) {}
};

如果不是在初始化列表中对 const 常量进行初始化，而是在构造函数中对其赋值的话，是不能成功的。很简单的道理：不能给 const 成员赋值。同样的道理，如果要初始化一个引用类型的成员变量，也不能在构造函数体内赋值，而只能在构造函数的初始化列表中进行初始化。

leijunan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录