C++之引用

大家好，我是牛牛。

今天给分享一下C++中引用的使用以及注意事项，主要包含以下几部分内容：

• 引用简介

• 引用的语法格式

• 引用规则

• 引用的应用

• 引用的本质

• 引用与指针的区别

一、引用简介

参数的传递本质上是一次赋值的过程 ，对于像 char、bool、int、float 等基本类型的数据，它们占用的内存往往只有几个字节，对它们进行内存拷贝非常快速。

而数组、结构体、对象是一系列数据的集合，数据的数量没有限制，可能很少，也可能成千上万，对它们进行频繁的内存拷贝可能会消耗很多时间，拖慢程序的执行效率。

C语言中在传递这种聚合类型数据时，建议传递指针。但是指针使用起来比较麻烦而且可读性差。

因此C++增加了一种比指针更加便捷的传递聚合类型数据的方式-引用。

引用同指针一样，能够减少数据的拷贝，提高数据的传递效率，而且比指针更加方便和易用。

二、引用的语法格式

type &name = data;

例如：

int a = 10;
int &p = a;

引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据,对引用的操作就相当于对数据的操作。

#include<iostream>

using namespace std;

int main()
{
    int a = 10;
    int &p = a;
    cout << p << " " << a << endl;
    cout << &p << " " << &a << endl; 
    p = 20;
    cout << p << " " << a << endl;
    return 0;
}

三、引用规则

1、引用只是别名，不占内存；和它引用的变量共用同一块内存空间；

2、引用仅在定义时带&,使用时普通变量一样使用,不含&;

3、引用必须在创建的时候初始化，一旦引用初始化后，就不能改变引用所指向的变量，类似于指针常量。

4、引用必须与一个确定的合法内存单元相关联,不存在NULL引用且不可以使用；

四、引用的应用

4.1 常引用

不能通过别名修改引用空间的数据，修饰形参可以防止在函数中对引用空间进行误操作;

格式：
const 数据类型 &别名 = 数据空间名；
const 数据类型 &别名

例如：

const int &n = 10;

4.2 引用作用与数组

①数组元素的类型 （&别名）[元素的个数] = 数组名；

int arr[3] = {20,100,45};
  int (&my_arr)[3] = arr;
  int i;
  for(i=0;i<3;i++)
  {
    cout << my_arr[i] << " ";
  }
  cout << endl;

②使用typedef 给数组元素的类型 [元素的个数]取别名，然后使用新类型名进行引用的定义

int arr[3] = {20,100,45};  
  typedef int TYPE_ARR[3]; // TYPE_ARR就是 int [3]类型的别名；
  TYPE_ARR &my_arr = arr; 
  int i;
  for(i=0;i<3;i++)
  {
    cout << my_arr[i] << " ";
  }
  cout << endl;

4.3 *引用作用于指针

给指针变量起别名，C语言使用二级指针指向一个指针，然后对指针空间进行操作，C++可以给指针起个别名进行指针空间的操作。

例如：将一个指针传递到函数中，在函数中申请一块空间，并赋值为“hello world”

①、使用二级指针：

#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;


void mallocFunc(char **p)
{
  *p = (char *)calloc(1,20);
  strcpy(*p,"hello world");
}


int main()
{
  char *str = NULL;
  // 在mallocFunc函数中为str申请一块空间，并赋值为"hello world" 
  mallocFunc(&str);
  cout << str << endl;
  return 0;
}

②、使用指针的引用：

#include<iostream>
#include<stdlib.h>
#include<string.h>


using namespace std;


void mallocFunc(char* &my_str)
{
  my_str = (char *)calloc(1,20);
  strcpy(my_str,"hello world");  

}


int main() 
{
  char *str = NULL;
  mallocFunc(str);
  cout << str << endl;
  return 0;
}

4.4、引用作为函数形参

#include <iostream>

using namespace std;
//  定义一个函数交换两个变量的值
// 值传递
void swap1(int a,int b)
{
    int temp = a;
    a = b;
    b = temp;
}
// 地址传递 - 在函数的内部修改函数外部空间里面的数据
// 产生副本
void swap2(int *p,int *p1)
{
    int temp = *p;
    *p = *p1;
    *p1 = temp;
}

//引用
// 在函数内部修改函数外部空间的数据
// 不产生参数副本
// 使用起来比指针要简单
void swap3(int &t,int &t1)
{
    int temp = t;
    t = t1;
    t1 = temp;
}

int main()
{
    int a = 20,b = 30;
    swap1(a,b);
    cout << "val :a:" << a << ",b:" << b << endl;


    int m = 40,n = 50;
    swap2(&m,&n);
    cout << "val :m:" << m << ",n:" << n << endl;


    int k = 3, j = 40;
    swap3(k,j);
    cout << "val :k:" << k << ",j:" << j << endl;
    return 0;
}

注意：如果使用引用作为参数不希望在函数内部改变引用空间的内容，可以在引用的前面加const修饰。

void swap3(const int &t,const int &t1)
{
    // .......
}

4.5、引用作为函数返回值-一般用于做迭代

#include<iostream>

using namespace std;

int &test()
{
  static int num = 1;
  return num;
}

int main()
{
  int &ret = test();
  cout << ret << endl;
  return 0;
}

注意：不要返回局部变量的引用，原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为”无所指”的引用，程序进入未知状态。

引用作为函数返回值的迭代应用：

#include <iostream>

using namespace std;
// 类 - 面向对象  属性和行为 -- 访问权限限制
class Person
{
public:
    int a = 30;
    void test1()
{
        cout << "test1" << endl;
    }

    void test2()
{
        cout << "test2" << endl;
    }


    Person test3()
{
        cout << "test3" << endl;


        return *this; // 返回的是对象 Person
    }


    void test4()
{
        cout << "test4:a:" << a << endl;
    }


    Person& test5(){
        cout << "test5" << endl;
        return *this;
    }


    void test6()
{
        cout << "test6:a:" <<a<< endl;
    }
};

int main()
{
    // 通过类创建一个对象 类名 对象名
    Person xiaoming;
    // 对象访问属性和行为 对象名.属性   对象名.函数名();
    cout << xiaoming.a << endl;
    xiaoming.a = 50;
    xiaoming.test1();
    xiaoming.test2();


    // 迭代 xiaoming.test1().test2(); // xiaoming.test1()函数执行完了之后要返回给我xiaoming这个对象
    //xiaoming.test1().test2();


    // 在函数中返回对象
    // 在类里面 this指针 指向你通过这个类创建的对象 -- 因此*this代表要返回的对象。
   Person xm = xiaoming.test3(); // 返回的是小明的副本 - 重新创建了一个对象，小明里面的数据复制了一份给它
  xm.test4();
  //小明的改变不会影响vm
  xiaoming.a = 100;
   xiaoming.test4();
  xm.test4();


    // 在函数中返回对象的引用
    Person& xm1 = xiaoming.test5();
    xm1.test6();
    xiaoming.a = 200;
    xiaoming.test6();
    xm1.test6();


    xiaoming.test5().test6();
    return 0;
}

五、引用的本质

引用的本质在C++中就是指针常量（常指针），typedef& ref = val; //typedef* const ref = &val;

引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的，引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节，之所以不能获取引用的地址，是因为编译器进行了内部转换。 

例如：

int a = 10;
  int &p = a;
  p = 18;
  cout<<&p<<endl;

编译器会转化为：

int a = 10;
int *p = &a;
*p = 18;
cout << p << endl;

总结：不是变量 p 不占用内存，而是编译器不让获取它的地址。 

六、引用与指针的区别

1、引用使用起来比指针便捷，可读性更强；

2、引用不占内存，指针占内存;

3、引用的值不能是NULL，指针的值可以是NULL;

4、指针有多级，引用只能有一级;

5、指针和引用的自增（++）自减（--）运算意义不一样。对指针使用 ++ 表示指向下一份数据，对引用使用 ++ 表示它所指代的数据本身加 1；自减（--）也是类似的道理。