References in C++

　　When a variable is declared as reference, it becomes an alternative name for an existing variable. A variable can be declared as reference by putting ‘&’ in the declaration.

 1 #include<iostream>
 2 using namespace std;
 3
 4 int main()
 5 {
 6   int x = 10;
 7
 8   // ref is a reference to x.
 9   int& ref = x;
10
11   // Value of x is now changed to 20
12   ref = 20;
13   cout << "x = " << x << endl ;
14
15   // Value of x is now changed to 30
16   x = 30;
17   cout << "ref = " << ref << endl ;
18
19   return 0;
20 }
21
22
23 　　Output:
25 　　x = 20
26 　　ref = 30

　　Following is one more example that uses references to swap two variables.

 1 #include<iostream>
 2 using namespace std;
 3
 4 void swap (int& first, int& second)
 5 {
 6     int temp = first;
 7     first = second;
 8     second = temp;
 9 }
10
11 int main()
12 {
13     int a = 2, b = 3;
14     swap( a, b );
15     cout << a << " " << b;
16     return 0;
17 }
18
19
20 Output:    3 2 

　　References  vs Pointers

　　Both references and pointers can be used to change local variables of one function inside another function. Both of them can also be used to save copying of big objects when passed as arguments to functions or returned from functions, to get efficiency gain.
　　Despite above similarities, there are following differences between references and pointers.

　　References are less powerful than pointers
　　1）Once a reference is created, it cannot be later made to reference another object; it cannot be reseated. This is often done with pointers.
　　2）References cannot be NULL. Pointers are often made NULL to indicate that they are not pointing to any valid thing.
　　3）A reference must be initialized when declared. There is no such restriction with pointers

　　Due to the above limitations, references in C++ cannot be used for implementing data structures like Linked List, Tree, etc. In Java, references don’t have above restrictions, and can be used to implement all data structures. References being more powerful in Java, is the main reason Java doesn’t need pointers.

　　上面的不同点可以总结为如下几条：

　　（1）引用始终与某个对象相关联的，因此引用在定义时必须进行初始化，而指针在定义时则可以不初始化；

　　（2）引用在定义后不能进行更改，而指针在定义后则可以更改，指向其他对象；

　　（3）赋值行为的差异：对引用赋值修改的是引用所关联对象的值，对指针赋值则修改的是指针本身的值；

　　（4）引用不能为NULL，而指针可以为NULL，因此，在编程的时候，引用的效率可能会比较高，因为不需要进行NULL判断。

　　References are safer and easier to use:
　　1） Safer: Since references must be initialized, wild references like wild pointers are unlikely to exist. It is still possible to have references that don’t refer to a valid location (See questions 5 and 6 in the below exercise )
　　2） Easier to use: References don’t need dereferencing operator to access the value. They can be used like normal variables. '&' operator is needed only at the time of declaration. Also, members of an object reference can be accessed with dot operator ('.'), unlike pointers where arrow operator (->) is needed to access members.

　　

　　Together with the above reasons, there are few places like copy constructor argument where pointer cannot be used.

　　Reference must be used pass the argument in copy constructor. Similarly references must be used for overloading some operators like ++.

Exercise:
　　Predict the output of following programs. If there are compilation errors, then fix them.

　　Question 1

 1 #include<iostream>
 2 using namespace std;
 3
 4 int &fun()
 5 {
 6     static int x = 10;
 7     return x;
 8 }
 9 int main()
10 {
11     fun() = 30;
12     cout << fun();
13     return 0;
14 }

　　Output：　　30

　　

　　Question 2

 1 #include<iostream>
 2 using namespace std;
 3
 4 int fun(int &x)
 5 {
 6     return x;
 7 }
 8 int main()
 9 {
10     cout << fun(10);
11     return 0;
12 }

　　编译错误：cannot convert parameter 1 from 'const int' to 'int &'

　　原因：fun函数的参数是non-const引用，而10字面值可以作为实参传递给const &，而不可以传递给&。

　　Question 3

 1 #include<iostream>
 2 using namespace std;
 3
 4 void swap(char * &str1, char * &str2)
 5 {
 6     char *temp = str1;
 7     str1 = str2;
 8     str2 = temp;
 9 }
10
11 int main()
12 {
13     char *str1 = "GEEKS";
14     char *str2 = "FOR GEEKS";
15     swap(str1, str2);
16     cout<<"str1 is "<<str1<<endl;
17     cout<<"str2 is "<<str2<<endl;
18     return 0;
19 }

　　Output：
　　str1 is FOR GEEK
　　str2 is GEEKS

　　Question 4

1 #include<iostream>
2 using namespace std;
3
4 int main()
5 {
6    int x = 10;
7    int *ptr = &x;
8    int &*ptr1 = ptr;
9 }

　　编译错误。将第8行代码改为int *&ptr1 = ptr; *&ptr1才是指针的引用。

　　Question 5

1 #include<iostream>
2 using namespace std;
3
4 int main()
5 {
6    int *ptr = NULL;
7    int &ref = *ptr;
8    cout << ref;
9 }

　　程序崩溃。因为没有NULL引用。

　　Question 6

 1 #include<iostream>
 2 using namespace std;
 3
 4 int &fun()
 5 {
 6     int x = 10;
 7     return x;
 8 }
 9 int main()
10 {
11     fun() = 30;
12     cout << fun();
13     return 0;
14 }

　　Output：10

　　注意该题的运行结果与Question 1运行结果不同原因。

　　题目解释如下：

　　question 4: you can't have a pointer to a reference because a pointer must point to an object and a reference itself is not an object, but an alias to another object. but you can have a reference to a pointer. int *&ptr1=ptr is legal - it means that ptr1 is a reference (alias) for the int pointer ptr.

　　question 5: the reference isn't technically NULL. it is referencing an actual object. however, that object is a pointer that is pointing to NULL.

　　question 6: a temporary object is created for the return type so that it can be printed by cout, after the line is executed, the temporary variable is destroyed.

　　

　　Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

　　转载请注明：http://www.cnblogs.com/iloveyouforever/

　　2013-11-25　　21:05:21