介绍
在C语言中，使用指针(Pointer)可以间接获取、修改某个变量的值;
在C++中，使用引用(Reference)可以起到跟指针类似的功能
int age = 10;
// rAge就是一个引用
int &rAge = age;
注意点
- 引用相当于是变量的别名(基本数据类型、枚举、结构体、类、指针、数组等，都可以有引用)
基本数据类型:
int age = 10;
int &rAge = age;
rAge = 30;
cout << age << endl; /// 30
枚举:
enum Seasion {
Spring,
Summer,
Fall,
Winter
};
int main(int argc, const char * argv[]) {
Seasion seasion;
Seasion &rSeasion = seasion;
rSeasion = Fall;
cout << seasion << endl; // 2
return 0;
}
结构体：
struct Student {
int num;
int score;
};
int main(int argc, const char * argv[]) {
Student stu;
Student &rStu = stu;
rStu.num = 20;
cout << stu.num << endl;
return 0;
}
指针:
int main(int argc, const char * argv[]) {
int a = 10;
int b = 30;
int *p = &a;
int *&rp = p;
rp = &b;
*p = 20;
cout << a << endl;
cout << b << endl;
return 0;
}
数组：
int main(int argc, const char * argv[]) {
int array[4] = {10, 30};
int (&rArray)[4] = array;
rArray[3] = 20;
cout << array[3] << endl;
return 0;
}
- 对引用做计算，就是对引用所指向的变量做计算
- 在定义的时候就必须初始化，一旦指向了某个变量，就不可以再改变，“从一而终”
- 可以利用引用初始化另一个引用，相当于某个变量的多个别名
int main(int argc, const char * argv[]) {
int age = 10;
/// rAge、rAge1、rAge2、rAge3都是对age的引用
int &rAge = age;
int &rAge1 = rAge;
int &rAge2 = rAge1;
int &rAge3 = rAge2;
rAge3 = 20;
cout << age << endl;
return 0;
}
- 不存在【引用的引用、指向引用的指针、引用数组】
int age = 10;
int &rAge = age;
int &&rAge1 = &rAge; /// 此行是错误的
int *&rAge2 = &rAge; /// 此行是错误的
int array[4] = {10, 30};
int &rArray[4] = array; /// 此行是错误的
引用存在的价值之一：比指针更安全、函数返回值可以被赋值
- 交换两个变量的值
void switchValue(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
int main(int argc, const char * argv[]) {
int v1 = 20;
int v2 = 30;
switchPosition(v1, v2);
cout << "v1 is " << v1 << endl;
cout << "v2 is " << v2 << endl;
return 0;
}
const
const是常量的意思，被其修饰的变量不可修改；
如果修饰的是类、结构体(的指针)，其成员也不可以更改
const修饰的是其右边的内容：
// *p0是常量，p0不是常量
const int *p0 = &age;
// *p1是常量，p1不是常量
int const *p1 = &age;
// p2是常量，*p2不是常量
int * const p2 = &age;
// *p3是常量，p3是常量
const int * const p3 = &age;
// *p4是常量，p4是常量
int const * const p4 = &age;
常引用
定义
被const修饰的引用，且const必须在&的左边
const引用的特点
- 可以指向临时数据(常量、表达式、函数返回值等)
int func() {
return 10;
}
int main(int argc, const char * argv[]) {
int a = 10;
int b = 20;
const int &c = a + b;
const int &d = func();
cout << c << endl;
cout << d << endl;
return 0;
}
- 可以指向不同类型的数据，此种情况在编译阶段，会生成一个临时变量，当修改被引用的变量的值时，引用变量的值仍然保留（稍后补汇编截图）
int age = 10;
const double &rAge = age;
age = 30;
cout << age << endl; /// 30
cout << rAge << endl; /// 10
- 作为函数参数时(此规则也适用于const指针)
可以接受const和非const实参(非const引用，只能接受非const实参)
可以跟非const引用构成重载
int sum(const int &a, const int &b) {
cout << "sum(const int &a, const int &b)" << endl;
return a + b;
}
int sum(int &a, int &b) {
cout << "sum(int &a, int &b)" << endl;
return a + b;
}
int main(int argc, const char * argv[]) {
int a = 10;
int b = 20;
cout << sum(a, b) << endl;
cout << sum(20, 30) << endl;
return 0;
}
当常引用指向了不同类型的数据时，会产生临时变量，即引用指向的并不是初始化时的那个变量
数组的引用
int array[] = {10, 20, 30};
int (&rArray)[3] = array;
int * const &rArray2 = array;
引用的本质：
- 就是指针，只是编译器削弱了它的功能，所以引用就是弱化了的指针
- 一个引用占用一个指针的大小
- 如何证明？
从代码角度
struct Student {
int &age;
};
int main(int argc, const char * argv[]) {
cout << sizeof(Student) << endl;
return 0;
}
从汇编角度
