C++的引用的使用

1引用的定义

引用时C++对C的一个重要的扩充,引用的作用是给变量起一个别名。

例如:

int a;

int &b=a;//声明b是a的引用

经过以上的声明,b就成为了a的别名,a和b的地位以及作用都是一样的。

将b声明为a的引用,不需要再为b开辟新的单元,b和a在内存中占同一存储单元,它们具有相同的地址。

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.          int a=10;
  5.          int &b=a;//声明b是a的引用
  6.          cout<<“b=”<<b<<endl;
  7.          a=a-5;
  8.          cout<<“b=”<<b<<endl;
  9.          b=b-1;
  10.          cout<<“a=”<<a<<endl;
  11.          return 0;
  12. }

 

 

在程序中,

声明了b是a的引用,然后输出b=10;

然后使a的值减小5,再输出b=5,说明b会随着a的变化做出变化;

然后使b的值减小1,再输出a=4,说明a会随着b的变化做出变化。

在声明一个引用的同时,必须同时对它进行初始化,即声明它代表哪一个变量。在声明变量b是变量a的引用后,就可以将b作为a的别名来进行操作,并且b不能再作为其他变量的引用(别名)。

声明引用,而不进行初始化操作:

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.          int a=10;
  5.          int &b;
  6.          return 0;
  7. }

编辑器报错

 

 

========================================

已经申明p为a的引用之后,在声明p为b的引用

 

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.          int a=10;
  5.          int &p=a;
  6.          int b=5;
  7.          int &p=b;
  8.          return 0;
  9. }

编辑器报错:

 

 

注意区分:

int &b=a;表示b是a的引用

int *b=&a;表示b是指针变量,并且b的值是a的地址

 

引用不是一种独立的数据类型,必须指定其代表的某一类实体(如变量,类对象),不能定义引用数组,不能定义指向引用的指针,也不能定义指针的引用。

 

2 引用作为函数的参数

C++增加引用机制,主要是把它作为函数参数,以扩充函数传递数据的功能。

函数的参数传递有三种情况

将变量名作为形参和实参

这是传给形参的是变量的值,传递是单向的。如果在执行被调用函数期间,形参的值发生变化,是不能反映到实参的。因为形参只是复制了实参的数值,两变量并不是占用同一存储单元。

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.     void change(int x,int y);
  5.     int i=3,j=2;
  6.     change(i,j);
  7.     cout<<i<<endl;
  8.     cout<<j<<endl;
  9.     return 0;
  10. }
  11. void change(int x,int y){
  12.        int z;
  13.        z=x;
  14.        x=y;
  15.        y=z;
  16. }

 

 

x复制了i的值,y复制了j的值。但i和j与x和y占不同的存储单元,因此只改变x和y的值,并不能改变i和j的值。

将变量地址作为实参,指针作为形参

这种方式仍然是值传递的方式,不过他传递的不是变量的数值,而是变量的地址。因此可以在被调用函数中,通过调用指针指向的变量来改变相应变量的值。

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.          void change(int * x,int * y);
  5.          int i=3,j=2;
  6.          change(&i,&j);
  7.          cout<<i<<endl;
  8.          cout<<j<<endl;
  9.          return 0;
  10. }
  11. void change(int * x,int * y){
  12.          int *z;
  13.          z=x;
  14.          x=y;
  15.          y=z;
  16. }

 

 

因为是值传递,所以只改变指针的值,而不去改变指向的变量的值,还是不能改变相应的变量的值。

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.          void change(int * x,int * y);
  5.          int i=3,j=2;
  6.          change(&i,&j);
  7.          cout<<i<<endl;
  8.          cout<<j<<endl;
  9.          return 0;
  10. }
  11. void change(int * x,int * y){
  12.          int *z;
  13.          *z=*x;
  14.          *x=*y;
  15.          *y=*z;
  16. }

 

 

当改变指针指向的变量的值的时候,相应的变量的数值也会发生变化。

 

将变量名作为实参,引用作为形参

将变量名作为形参和实参和将变量地址作为实参,指针作为形参都是采用的值传递的方式。而引用作为形参的时候,采用的是地址传递的方式。

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.     void change(int & x,int & y);
  5.     int i=3,j=2;
  6.     change(i,j);
  7.     cout<<i<<endl;
  8.     cout<<j<<endl;
  9.     return 0;
  10. }
  11. void change(int & x,int & y){
  12.         int z;
  13.         z=x;
  14.         x=y;
  15.         y=z;
  16. }

 

在函数change的形参中声明了a,b是整形变量的引用。当main函数调用change函数时,把实参i的地址传递给形参x,把实参j的地址传递给形参y,从而使i和x共享同一个单元,使j和y共享同一个单元。也可以理解成,把i的变量名传递给了x,把j的变量名传递给了y。

引用作为形参与指针变量作为形参的区别

1使用引用类型,就不必在swap函数中声明形参是指针变量。指针变量要另外开辟内存单元,其内容是地址。而引用不是一个独立的变量,不单独占内存单元,引用的数据类型应该应该与实参相同。

2 在main函数中,实参不必用变量的地址,而是直接用变量名。系统向形参传递的是实参的地址而不是实参的值。

3 由于不能声明指针的引用,那我们如何像指针那样传递可以通过传递数组的首元素来实现传递整个数组的数据呢?

使用指针作为形参:

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4. void Print(int *p,int n);
  5.     int a[5]={1,2,3,4,5};
  6.     Print(a,5);
  7.     return 0;
  8. }
  9. void Print(int *p,int n){
  10.     int i;
  11.     for(i=0;i<n;i++){
  12.         cout<<p[i]<<endl;
  13.     }
  14. }

 

=============================================================================

使用引用作为形参

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4. void Print(int &p,int n);
  5.     int a[5]={1,2,3,4,5};
  6.     Print(a[0],5);
  7.     return 0;
  8. }
  9. void Print(int &p,int n){
  10.     int i;
  11.     int *a=&p;
  12.     for(i=0;i<n;i++){
  13.        cout<<a[i]<<endl;
  14.     }
  15. }

 

因为引用就是给原来的变量起了别名,并且不能声明指针的引用,所以我们就声明指针指向的变量的引用,然后再对引用取地址,就达到了这个目的。

为了更清楚的说明,下面再举一个例子:

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.    int i=10;
  5.    int *p;
  6.    p=&i;//将i的地址赋给指针p
  7.    int &y=*p;//将y作为指针p指向的变量的引用
  8.    cout<<y<<endl;
  9.    if(&y==p)cout<<“succeed”<<endl;//检查y的地址和指针p的值是否相等
  10.    return 0;
  11. }

 

 

[cpp][/cpp] view plaincopy

  1. #include<iostream>
  2. using namespace std;
  3. int main(){
  4.    int a[5]={1,2,3,4,5};
  5.    int &y=a[0];//声明y作为数组的首元素的引用
  6.    int *p=&y;//将y的地址赋给指针p
  7.    int i=0;
  8.    for(;i<5;i++){
  9.       cout<<p[i]<<endl;
  10.    }
  11.    return 0;
  12. }

标签