引用

引用不能为空，引用必须进行初始化

一、引用的定义 

例1：

int  main(){

  int a=100;

  int & ref=a;                                   //ref是a的引用，ref就是变量a的别名,即a还有一个名字叫ref

  ref=5;

  cout << "a=" << a <<endl;              //对ref操作就是对a操作，所以输出5

  cout << "ref=" << ref <<endl;         //输出5

}

例2：

int main(){

  int a =100;

  int &b;                                          //错误。引用必须要初始化，一定要有一个实体存在。因为既然是别名，一定要有个原名在。

}

例3:                                                  

int main(){

  int &a=1;                                       //错误。1是字面值，是一个右值，

  &1;                                               //错误,1是一个字面值(literal)常量，不能进行取地址操作。

  const int &c=1;     //正确

}

例4：

int main(){

  int a=100;

  int b=200;

  int &ref=a;

  ref=b;                               //这一句的意思是把b的值赋给a。而不是将ref变为b的别名。这说明,引用一经初始化，不会再改变指向。

}

二、引用和指针的关系

引用与指针的相同点：

1.都有地址的概念在里面(引用的底层实现是指针)

引用和指针的区别：

1.引用不能为空，指针可以是空的。

2.引用必须进行初始化，指针可以不初始化。

3.引用一经绑定某个变量，之后就不能再修改其指向。指针没有这个限制。

三、引用的使用

3.1 引用的使用：作为形参 

例1：交换两个变量的值的指针写法 

void swap(int *px,int *py){                    //地址传递，本质是值传递，即复制  

  int tmp=*px;

  *px=*py;

  *py=tmp;

}

int main(){

  int a=3;

  int b=4;

  swap(&a,&b);

  cout << "a=" << a << endl;

  cout << "b=" << b << endl;

  return 0;

}

例子2：用引用实现交换两个指针的值

void swap(int & refx, int & refy){            //使用引用。refx与a绑定，refy与b绑定。refx就是a,refy就是b。在函数传参数,不需要进行复制,                                                                直接操作实参a和b本身,会减少复制的开销,从而能够提高执行效率; 在使用时更直观,更易理解。

        int temp = refx;

        refx = refy;

        refy = temp;

}

int main(){

        int a = 3;

        int b = 4;

        swap(a, b);

        cout << "a = " << a << endl;

        cout << "b = " << b << endl;

        return 0;

}

                                                      引用的理解：编译好后，引用就没了。

3.2 引用的使用：作为返回值   

例1：可以返回全局变量的引用

int arr[5] = {0, 1, 2, 3, 4};

int & func(){                                   //返回arr[0] 

        return arr[0];                          

}

int main(){

  func()=10;                                //arr[0]=10; 

  cout << arr[0] << endl;              //输出10     

  return 0;

}

例2：不能返回局部变量的引用。

int & func1(){

  int a=4;

  return a;                                   //这是错误的,不能返回局部变量的引用。函数运行结束后,局部变量被销毁。

}

int main(){                

  cout << func1() << endl;          

  return 0;

}

类似与C语言中，不能返回局部变量的指针。

int * fun(){

  int a=3;

  return &a;                               //错误。因为函数运行完后,a被销毁了

}

例3：不要轻易返回堆空间对象的引用。

int & func(){                                  //返回的是一个堆空间对象的引用。因为函数是封装好了的，我在main中需要使用func函数的功能，                                                        并不一定知道func函数在里面申请了空间。所以在main中不一定知道要释放空间，而且使用的时候并                                                      一定会先接收保存下来，这样就会造成内存泄漏。

        int * px = new int(10);

        return *px;                             

}

int & func3(){                                

        int * px = new int(10);

        return *px;                             

}

int main(){

        int & b = func();

        cout << "b = " << b << endl;

        delete (&b);                              //使用一：正确，自己销毁。前提是我知道func()函数申请了内存，并且我保存了下来。

   cout <<  a + func3() << endl;    //使用二：错误。调用了一下func3,调用完了就完了,并没有使用变量保存func3(),这样func函数申请                                                           的空间就泄漏掉了。这样只要程序不结束，每一次调用func函数都会泄漏一点内存。 

}