- 引用可以看作一个已经定义变量的别名
- 与原变量在同一片内存空间
- 引用语法: type& name = var;
int a = 4;
int& b = a; //b为a的别名
b = 5; //操作b就是操作a
- 引用传递数组
fun(int (&array)[10]);
普通引用在定义时必须用同类型变量进行初始化。
- 当三目运算符的可能返回都是变量时,返回的是变量引用
- 当三目运算符的可能返回中有常量时,返回的是值
int a = 1;
int b = 2;
(a<b?a:b) = 3;//正确,返回a或者b的引用,可以作为左值
(a<b?1:b) = 4;//错误,返回1或者b的值,不能作为左值
- 当使用常量对const引用进行初始化时,c++编译器会为常量值分配空间,并且将引用名作为这段空间的别名
const int& b =1;//ok
int *p = (int*)&b;
b =5;//error,只读变量
*p = 5; //ok
int a = 4;
const int& b = a;
a = 3; //编译通过
b = 3; //编译出错
使用常量对const引用初始化后将生成一个只读变量(不是常量,不会进入常量表)
- 引用有自己的存储空间,因为其本质就是指针
- 引用在 c++ 内部实现是一个指针常量
- c++编译器在编译过程中使用指针常量作为引用的内部实现,因此== 引用的空间大小和指针相同 ==
void f(int& a) <==> void f(int* const a)
{ {
a = .. *a = ..
} }
int& a <==> int* const a
#include <stdio.h>
struct TRef
{
char& r;
};
int main(int argc, char *argv[])
{
char c = 'c';
char& rc = c;
TRef ref = { c };
printf("sizeof(char&) = %d\n", sizeof(char&)); //1
printf("sizeof(rc) = %d\n", sizeof(rc)); //1
printf("sizeof(TRef) = %d\n", sizeof(TRef)); //4
printf("sizeof(ref.r) = %d\n", sizeof(ref.r)); //1
return 0;
}
#include <stdio.h>
struct TRef
{
char* before;
char& ref;
char* after;
};
int main(int argc, char* argv[])
{
char a = 'a';
char& b = a;
char c = 'c';
TRef r = {&a, b, &c};
printf("sizeof(r) = %d\n", sizeof(r)); //12
printf("sizeof(r.before) = %d\n", sizeof(r.before)); //4
printf("sizeof(r.after) = %d\n", sizeof(r.after)); //4
printf("&r.before = %p\n", &r.before); //4
printf("&r.after = %p\n", &r.after);
return 0;
}
函数返回引用
- 不能返回局部变量的引用(因为引用内部使用常量指针实现,相当于返回局部变量的地址)
#include <stdio.h>
int& demo() //int * const
{
int d = 0;
printf("demo: d = %d\n", d);
return d; //错误
}
int& func()
{
static int s = 0; //全局存储区,所以可以返回引用
printf("func: s = %d\n", s);
return s;
}
int main(int argc, char* argv[])
{
int& rd = demo(); //野引用
int& rs = func();
printf("\n");
printf("main: rd = %d\n", rd);
printf("main: rs = %d\n", rs);
printf("\n");
rd = 10;
rs = 11;
demo();
func();
printf("\n");
printf("main: rd = %d\n", rd);
printf("main: rs = %d\n", rs);
printf("\n");
return 0;
}