当前位置：GoMCU > 未分類 > 正文

[轉] C++中Reference与指针（Pointer）的使用对比

2013-06-03 分类：未分類 评论(0)

出處：http://www.360doc.com/content/08/0726/16/70532_1472760.shtml

引用(reference)和指针(pointer)是学C++过程中最令人头疼的问题，常常不知道什么时候用哪个合适，又常常弄混。找到Dan Saks的这篇文章，讲的很清楚，强烈推荐，所以翻译一下供大家参考。
———————————————————————————
以下译自Dan Saks的文章 References vs. Pointers 英文原文
———————————————————————————
了解引用reference与指针pointer到底有什么不同可以帮助你决定什么时候该用reference，什么时候该用pointer。
在C++ 中，reference在很多方面与指针(pointer)具有同样的能力。虽然多数C++程序员对于何时使用reference何时使用pointer 都会有一些直觉，但总还是会有些时候搞不清楚。如果你想要建立一个关于使用reference使用的清晰有理的概念，又有必要了解到底reference和pointer有什么不同。

深层含义

与pointer 类似，一个reference是一个对象(object)，可以用来间接指向另一个对象。一个reference的声明与pointer的声明的实质语法结构是相同的。不同的是，声明pointer的时候使用星号操作符 * ， 而声明reference的时候使用地址操作符 & 。 例如，我们有:
int i = 3;
则有:
int *pi = &i;
声明 pi 为一个指针类型的对象，并且是一个”指向int整型的指针”，它的初始值为对象i的地址。而另一方面：
int &ri = i;
声明 ri为一个reference类型的对象，并且也是一个指向整型的reference，它指向的是i。我们可以看到pointer和reference的声明有显著的不同，但这并不是决定何时使用哪一个的根据。决定的真正依据是当它们被用在表达式中时其显示的不同决定了使用哪一个合适
Pointer 和reference的最大不同是：pointer必须使用一个星号操作符 * 来去掉reference （英文叫做dereference，我不知道这里怎样翻译这个词合适，姑且就叫“去参考”吧）而reference不需要任何操作符来去参考。例如，有了上面例子中的定义， 间接表达式 *pi 将 pi 去参考为指向i。相反，表达式ri-不需要任何操作符-自动将ri去参考为指向i。因此， 使用指针p，我们需要用赋值语句:
*p = 4;
将i的值变为4； 而使用reference ri，我们只需要直接写：
ri = 4;
就可以同样将i的值变为4 。
这个显示的不同在当你为函数的参数类型和返回值类型选择是使用pointer还是reference的时候就会显著起来，尤其是对于重载操作符的函数。
下面使用一个针对列举类型（enumeration）的++操作符例子来说明上面这点。在C++中，内置的++操作符对列举类型无效，例如，对下面定义：

enum day{
Sunday, Monday, …
};
day x;

表达式 ++x 不能编译。如果想让它通过编译，必须要定义一个名为operator++的函数，接受day为参数，并且调用 ++x 必须改变x的值。因此， 仅声明一个函数 operator++ ， 以类型day为参数， 如下:
day operator++(day d);
并不能够得到想要得效果。 这个函数通过值传递参数(pass by value)，这就意味着函数内看到的是参数的一个拷贝，而不是参数本身。为了使函数能够改变其操作数(operand)的值，它必须通过指针或reference来传递其操作数。
通过指针传递参数(passing by pointer)，函数定义如下:
day *operator++(day *d);
它通过将增加后的值存储到*d里面来使函数改变日期(day)的值。但是，这样你就必须使用像表达式++&x这样来调用这个操作符，这看起来不太对劲儿。
正确的方法是定义operator++以reference为参数类型，如下:

day &operator++(day &d)
{
d = (day)(d + 1);
return d;
}

使用这个函数， 表达式 ++x 才有正确的显示以及正确的操作。
Passing by reference不仅仅是写operator++较好的方法，而是唯一的方法。 C++在这里并没有给我们选择的余地。 像下面的声明:
day *operator++(day *d);
是不能 通过编译的。每个重载的操作符函数必须或者是一个类的成员， 或者使用类型T、 T & 或 T const & 为参数类型，这里T是一个类(class)或列举(enumeration)类型。也就是说，每一个重载操作符必须以类或列举类型为参数类型。指针，即使是指向一个类或列举类型对象的指针，也不可以用。C++ 不允许在重载操作符时重新定义内置操作符的含义，包括指针类型。因此，我们不可以定义：
int operator++(int i); // 错误
因为它试图对int重新定义操作符 ++ 的含义。 我们也不可以定义：
int *operator++(int *i); // 错误
因为它试图对 int * 重新定义操作符 ++ 的含义。

References vs. const pointers

C++ 中不允许定义”const reference”，因为一个reference天生就是const。也就是说，一旦将一个reference绑定到一个对象，就无法再将它重新绑定到另一个不同的对象。在声明一个reference之后没有写法可以将它重新绑定到另外一个对象。例如：
int &ri = i;
将 ri 绑定到 i 。然后下面的赋值:
ri = j;
并不是把 ri 绑定到 j ，而是将 j 中的值赋给 ri 指向的对象，也就是赋给 i 。
简而言之，一个pointer在它的有生之年可以指向许多不同的对象，而一个reference只能够指向一个对象。有些人认为这才是 reference和 pointer最大的不同。我并不赞成。也许这是reference与pointer的一点不同，但并不是reference和const pointer的不同。在强调一遍，一旦一个reference与一个对象绑定，就不能再将它改指向另外的东西。既然不能再绑定reference之后再改变，一个reference就必须在一出生就被绑定。否则这个reference就永远不能被绑定到任何东西，也就毫无用处了。
上一段的讨论也同样完全适用于常量指针（const pointer）。（注意，我这里说的是常量指针（const pointer），而不是指向常量的指针 “pointers to const”。) 例如，一个reference声明必须同时带有一个初始化赋值，如下所示：

void f()
{
int &r = i;
…
}

省略这个初始化赋值将产生一个编译错误：

void f()
{
int &r; //错误
…
}

一个常量指针的声明也同样必须带有一个初始化赋值，如下所示：

void f()
{
int *const p = &i;
…
}

省略这个初始化赋值同样会出错：

void f(){
int *const p; // 错误
…
}

在我看来，不能够对reference二次绑定作为reference与pointer的不同。并不比常量指针和非常量指针的不同更为显著。

Null references

除了显示的不同，常量指针与reference还有一点非常不同，那就是，一个有效的reference必须指向一个对象；而一个指针不需要。一个指针，即使是一个常量指针，都可以有空值。一个空指针不指向任何东西。
这点不同就暗示当你想要确信一个参数必须指向一个对象的时候，应该使用reference作为参数类型。 例如，交换函数(swap function)，它接受两个int参数，并将两个参数的数值对调，如下所示：

int i, j;
swap(i, j);

将原本在 i 中的值放到 j 中， 并将原本在 j 中的值放到 i 中。我们可以这样写这个函数：

void swap(int *v1, int *v2)
{
int temp = *v1;
*v1 = *v2;
*v2 = temp;
}

这种定义下，函数要像这样被调用: swap(&i, &j);
这个接口暗示其中一个或两个参数都有可能为空(null)。而这个暗示是误导的。例如，调用
swap(&i, NULL);的后果很可能是不愉快的。
而像下面这样定义reference为参数：

void swap(int &v1, int &v2)
{
int temp = v1;
v1 = v2;
v2 = temp;
}

清晰的表明了调用swap应该提供两个对象，它们的值将被交换。并且这样定义的另一个好处是，在调用这个函数的时候，不需要使用那些&符号，看起来更顺眼：
swap(i, j);

更安全?

有些人认为既然reference不能够为空，那么它应该比指针更安全。我认为reference可能要安全一点，但不会安全很多。虽然一个有效的reference不能为空，但是无效的可以呀。实际上，在很多情况下程序有可能产生无效的reference，而不只是空的reference。例如，你可以定义一个reference，使它绑定到一个指针指向的对象，如下所示：

int *p;
…
int &r = *p;

如果指针*p在reference定义时刚好为空，则这个reference为空。从技术上来说，这个错误并不在于将reference绑定到一个空值，而是在于对一个空指针去参考。对一个空指针去参考产生了一个不确定的操作，也就意味着很多事都可能发生，而且大部分都不是什么好事。很有可能当程序将reference r 绑定到*p (p所指向的对象)的时候，p实际上没有被去参考，甚至程序只是将p的值拷贝给实现r的指针。而程序将会继续执行下去直到错误在后面的运行中更为明显的表现出来，产生不可预知的危害。
下面的函数展示了另外一种产生无效reference的方法：

int &f()
{
int i;
…
return i;
}

这个函数返回一个指向本地变量 i 的reference。然而当函数返回时，本地变量 i 的存储空间也就消失了。因此这个函数实际返回了一个指向被回收了的空间的reference。这个操作与返回一个指向本地变量的指针的后果相同。有些编译器可以在编译时发现这个错误，但也很有可能不会发现。
我喜欢reference，也有很好的理由使用它们代替pointer。但如果你期望使用reference来使你的程序健壮性显著增强，那么你多半会失望的。

以指针或reference为参数的C++函数定义与调用对照表

初学者不易建立清晰的指针和reference概念，总结这个表以供快速参考：
假设有对象定义:
MyObjectType obj1;
1. 值传递:
如果函数定义为:
void myFunction( MyObjectType obj);
函数调用:
myFunction(obj); //函数以外对象obj的值不会 改变
2. reference传递:
如果函数定义为:
void myFunction( MyObjectType &obj);
函数调用:
myFunction(obj); //函数以外对象obj的值会 改变
3. 指针传递:
如果函数定义为:
void myFunction( MyObjectType *obj);
函数调用:
myFunction(&obj); //需要dereference(&), 函数以外对象obj的值会 改变

参考资料：

  1. Saks, Dan. “Introduction to References,” Embedded Systems Programming, January 2001, p. 81.
  2. Saks, Dan. “References and const“, Embedded Systems Programming February 2001, p. 73.
================================================================
        void swap(int &x, int &y)   // call by reference
        {
            int temp;

            temp = x;  x = y;  y = temp;
        }

 main()
        {
             int i, j;

             cout << "Input 2 numbers:" << endl;
             cin >> i >>j;

             if( i > j ) 
                 swap(i, j);

             cout << "The smaller number is " << i << endl;
             cout << "The larger is " << j << endl;

 };

說明：

  1. 函數呼叫 swap(i, j) 時， 引數的 傳遞 如同
    int &x=i; int &y=j;。
  2. 引數 x 為 變數 i 的 別名， y 為 變數 j 的 別名。
  3. 於函數 swap 中， 改變 引數 x 與 y 的值， 變數 i 與 j 也隨著 改變。
  4. 該程式 執行 的 結果 為：
    Input 2 numbers:
100  50
The smaller number is 50
The larger is 100

        class CA
        {
          private:
            int y;
          public:
            int x;
            CA():x(0){}     // x is initialized to 0
            int &f(int y)
            { x = y+20; return x;}
            int &g()
            { return y;}
        };

 main()
        {
             CA a;

             a.x = 2;
             a.f(2) = a.x + 3; // 函數呼叫 位於 等式 左側
             a.g() = 10;       // private 變成 public
             cout << "a.x = " << a.x << endl;
             cout << "a.y = " << a.g() << endl;
 };

說明：

  1. 函數呼叫 a.f(2) 時， a.x = 22， 又 a.f(2) 函數值 為 a.x， 因此，
    a.f(2) = a.x + 3;
    就 如同 下列 程式碼：
    a.x = y + 20;
    a.x = a.x + 3;
  2. 函數呼叫 a.g() = 10; 時， 即 a.y = 10;， 此時， private data member y 變成 public data member。
  3. 該程式 執行 的 結果 為：
    a.x = 25
    a.y = 10
        int &f()
        {
            static int x = 0;
            x++;     // x 可用來記錄函數被呼叫的次數
            return x;
        }

 main()
        {
             int i;

             f();f();f();
             i = f();
             cout << "函數 f() 被呼叫 " << i << " 次" << endl;

             i = f() = 0; // 從新設定 static 變數 x 為 0
             cout << "從新設定後， 函數 f() 被呼叫 " << i << " 次" << endl;
 };

說明：

  1. 函數 f() 所傳回的值為 函數 f() 中的 static 變數 x 的參考型態值， 即 變數 x 本身。

該程式 執行 的 結果 為：

函數 f() 被呼叫 4 次
從新設定後， 函數 f() 被呼叫 0 次
=========================================================
 C++: Reference (參考)

前面一篇講了pointer，這篇要講只有C++才有的reference，
C是沒有reference的，相較於pointer，reference顯得平易近人多了!
reference有個很大的特性，它的意思是別名(alias)的意思!
reference不像pointer記錄著變數的記憶體位置，它只是變數的別名!

下面用個簡單的例子講解：

1int iValue = 2;
2int &iReference = iValue;
3cout << iReference << endl;   //會印出2
4cout << &iReference << endl;  //會印出iValue 的記憶體位置
5cout << &iValue << endl;　　　 //會印出iValue本身自己的記憶體位置

上面的範例宣告了一個整數變數（iValue)，和一個參考變數（iReference) 第一行會先印出2，
因為前面說過參考只是別名， 意思就是說iReference是iValue的別名，
在白話一點iReference等於iValue，
所以第二行會印出iReference(也就是iValue)的記憶體位置，假設印出0x28ff44（每台電腦都不一定是這個值）
第三行就是印出iValue自己的記憶體位置，所以！！！它也會印出0x28ff44!! 跟第二行一樣!! (因為他們兩個相等咩)

reference跟pointer不一樣的還有幾點，
reference一定要有初始值!!!
取值不需要加上*!!

不過其實參考使用的時機大部分是用在函數時， 因為是別名，所以可以避免複製大量的變數到函數去(就算是pointer函數，也會複製)
下面是一個簡單的參考函數範例：

01void fnReference(int &iValue){
02     iValue = iValue +1;
03     cout << iValue << endl;       
04}
05main(){ 
06           
07     int iValue = 2;
08     fnReference(iValue);
09     cout << iValue << endl;
10         
11     system(“pause”);
12     return 0;
13}


在上面的範例我們宣告了一個函數（fnReference），其傳遞參數為參考型態（&iValue）
在主程式中(main)，傳遞了單純的整數變數進去，
跟pointer不一樣，pointer是傳記憶體位置進去，
參考就直接傳普通的變數進去，
我們在函數中把傳遞進去的參數+1，然後印出，會印出3，
回到主程式以後，在印出iValue，一樣會印出3。
因為我們是傳遞參考，這就是call by reference！

最後，reference還有一個跟pointer不一樣的點！
就是reference不能用來進行運算!!!!!


未經允許不得轉載：GoMCU » [轉] C++中Reference与指针（Pointer）的使用对比
标签：
相關推薦