c++ 入门 - 引用（一）

什么是引用

• 在c++中，可以使用引用可以起到跟指针类似的功能
  如：

 int age = 20;
// rAge就是一个引用
 int &rAge = age;

• 引用相当于是变量的别名，可以用于基本数据类型、枚举、结构、类、指针、数组等
  如:
  基本数据类型

int age = 20;
// rAge就是一个引用
 int &rAge = age;

枚举：

enum Season {
    Spring,
    Summer,
    Fall,
    Winter
};

    Season season;
    Season &rSeason = season;
    rSeason = Winter;
    cout << season << endl;

输出结果为：3

结构体：

struct Student {
    int age;
};
    Student stu;
    Student &rStu = stu;
    rStu.age = 20;
    cout << stu.age << endl;

输出结果为：20

指针：

    int a = 10;
    int b = 20;
    int *p = &a;
    int * &rp = p;
    rp = &b;
    *p = 30;
    cout << a << "," << b << endl;

输出结果为：10,30

数组：

    int array[] = {10, 20, 30};
    int (&rArray)[3] = array;
    cout << rArray[0] << endl;

输出结果为：10

• 对引用做计算，就是对引用所指向的变量做计算
  如：

  int a = 10;
  int b = 20;
  int &ra = a;
  int &rb = b;
  int c = ra + rb;
  cout << c << endl;

• 在定义引用的时候就必须初始化，一旦指向了某个变量。就不可以再改变，“从一而终”
• 可以利用引用初始化另一个引用，相当于某个变量的多个别名
  如：

    int a = 10;
    int &ra = a;
    int &rb = ra;
    cout << ra << endl;
    cout << rb << endl;

• 不存在引用的引用，指向引用的指针，引用数组

和指针的比较

• 比指针更安全，因为引用定义的时候就初始化了，指向了某个变量就不能再改变，所以比指针更安全
• 函数的返回值可以被赋值
  如：

int age = 10;

int &func(){
    return age;
}

func() = 30;
cout << "a = " << age << endl;

输出结果：a = 30

const

• const就是常量的意思，器修饰的变量不可改变
  -如果是修饰的是类、结构体（的指针），其成员也不可改变
• const 修饰的是它右边的功能
  如 ：

    int age = 10;
    const int *p0 = &age;
    int const *p1 = &age;
    const int * const p3 = &age;
    int const * const p4 = &age;

因为const总是修饰他右边，所有*po 和 *p1 都是常量 po和p1 是变量，
而p3 和 p4 p3和p4，都被const 修饰了，所有他们都是常量 。

常引用

• 引用也是可以被const修饰的，这样就无法通过引用修改数据了，我们可以称为常引用
• const必须写在&符号的左边，才能算常引用
  如

    int age = 10;
    int const &rage = age;

• 常引用可以指向不同类型的数据
• 常用语可作为函数参数(此规则也是用与const的指针)
  如：

int sum(const int &a, const int &b){
    return a + b;
}

有如下的特点
1、可以接受const和非const的实参（而非const的引用，只能接受非const实参）

    int v1 = 10;
    int v2 = 20;
    sum(v1, v2);

    const int v3 = 30;
    const int v4 = 40;
    cout << sum(v3, v4) << endl;

2、可以和非const引用构成重载
如：

int sum(const int &a, const int &b){
   return a + b;
}

int sum(int &a, int &b){
   return a + b;
}

• 当常引用指向了不同类型的数据时，会产生临时变量，就是引用指向的并不是初始化时的那个变量