写在前面
C++与C有一点不同之处就有引用,那么什么是引用,为什么要有引用,引用可以干什么,引用与指针的区别以及引用的使用场景,耐心看完这一篇,这些问题将会得到解答。
什么是引用
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它 引用的变量共用同一块内存空间。
----------------------------------------------------------------
就好比你自己本身有个大名,然后在家里人叫你的小名,你的女朋友叫你的昵称,你还是宿舍中其他几个“儿子”的“爸爸”(doge)一样。
类型& 引用变量名(对象名) = 引用实体;
void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}
注意:引用类型必须和引用实体是同种类型的(你永远都是你,只是有了不同的名字)
引用的特性
1. 一个变量可以有多个引用
2. 引用在定义时必须初始化
3. 引用一旦引用一个实体,再不能引用其他实体
void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;
printf("%p %p %p\n", &a, &ra, &rra);
}
常引用
有以下几种错误类型
void TestConstRef()
{
const int a = 10;
//int& ra = a; // 出错,a为常量
const int& ra = a;
// int& b = 10; // 出错,b为常量
const int& b = 10;
double d = 12.34;
//int& rd = d; // 出错,类型不同
const int& rd = d;
}
1.不可以权限扩大,只能权限缩小(如下)
int main()
{
const int a = 10;
int& ra = a;
return 0;
}
错误
----------------------------------------------
int main()
{
int a = 10;
const int& ra = a;
return 0;
}
正确
2.未进行初始化(如下)
int main()
{
int& a ;//错误,编译不能通过
return 0;
}
3.只有小名,没有大名
int main()
{
int& a =10;//错误,编译不能通过
return 0;
}
4.类型不同
引用的使用场景
1.做参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
2. 做返回值
int& Count()
{
static int n = 0;
n++;
// ...
return n;
}
注意(易错点)
#include <iostream>
using namespace std;
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is: " << ret << endl;
return 0;
}
思考一下会出现什么结果
-
-
-
-
因为ret是c的别名,所以在进行Add(1,2)完成后有进行Add(3,4),导致变量ret再次发生改变,输出为7。
如何避免
#include <iostream>
using namespace std;
int& Add(int a, int b)
{
static int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is: " << ret << endl;
return 0;
}
static会让c的初始化只执行一次,同时返回值 ret 也就不会再改变了。(地址还是同一个地址,只是跳过了运行,不要与const搞混,static对于权限还是没有改变,而const则是改变了权限)
------------------------------------------------------------------------------------------------------------
也就是说
如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已 经还给系统了,则必须使用传值返回。
效率比较
传值、传引用效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是 传递实参或者返回变量的一份临时的拷贝,因此用值作为参数或者返回值类型,效率是非常低下的,尤其是 当参数或者返回值类型非常大时,效率就更低。(就好比提前准备与需要时临时准备)
#include <iostream>
#include <time.h>
struct A {
int a[10000];
};
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
std::cout << "TestFunc1(A)-time: " << end1 - begin1 << std::endl;
std::cout << "TestFunc2(A&)-time: " << end2 - begin2 << std::endl;
}
有兴趣的同学运行一下
值和引用的作为返回值类型的性能比较
#include <iostream>
#include <time.h>
struct A {
int a[10000];
};
A a;
// 值返回
A TestFunc1() {
return a;
}
// 引用返回
A& TestFunc2(){
return a;
}
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
std::cout << "TestFunc1 time: " << end1 - begin1 << std::endl;
std::cout << "TestFunc2 time: " << end2 - begin2 << std::endl;
}
引用与指针
// 引用和指针的不同点
#include <iostream>
int main()
{
// 定义一个整型变量x,并将其赋值为10
int x = 10;
// 定义一个引用y,引用x
int& y = x;
// 定义一个指针p,指向x
int* p = &x;
// 输出x、y、p的值
std::cout << "x: " << x << std::endl; // x: 10
std::cout << "y: " << y << std::endl; // y: 10
std::cout << "p: " << p << std::endl; // p: address of x
// 修改y和*p的值
y = 20;
*p = 30;
// 再次输出x、y、p的值
std::cout << "x: " << x << std::endl; // x: 30
std::cout << "y: " << y << std::endl; // y: 30
std::cout << "p: " << p << std::endl; // p: address of x
// 在sizeof中含义不同
std::cout << "sizeof(y): " << sizeof(y) << std::endl; // sizeof(y): 4
std::cout << "sizeof(p): " << sizeof(p) << std::endl; // sizeof(p): 4
return 0;
}
在上述代码中,我们看到引用和指针的一些不同点,包括:
1.引用在定义时必须初始化,指针没有要求
2.引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体
3.没有NULL引用,但有NULL指针
4.在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节)
5.引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
6.有多级指针,但是没有多级引用
7.访问实体方式不同,指针需要显式解引用,引用编译器自己处理
8.引用比指针使用起来相对更安全
需要注意的是,在一些特殊情况下,使用指针会更加方便,例如动态分配内存等。
结语
谢谢观看,本小生亦为初学之一,如有错误敬请指出,一起进步呀