目录
1.引用的概念
2.引用的性质
3.常量引用
4.使用场景
1.作参数
2.作返回值
5.传值与传引用的效率比较
6.值和引用作为返回值的性能比较
7.引用与指针
指针与引用的不同点
要说C语言中哪个知识点最难学难懂,大部分人可能和我一样的答案——指针。C++既然是C语言的豪华升级版肯定要优化这一问题。不过指针虽然难,但是不得不说它确实牛*呀,指针使C语言变得更加灵活更加万能,可以说指针是C/C++的精髓,因此取缔指针是万万不能的,所以C++的祖师爷引进了引用的概念。
1.引用的概念
引用:给已经存在的变量取个别名;编译器不会为引用变量开辟新的内存空间,它和引用的变量共用同一块内存空间;
例如:小明的小名叫作明明,不管是“明明”还是“小明”都指的是同一个人;
格式:类型& 引用变量名 = 被引用的实体;
//例如 ra 为 a 的引用
int a = 0;
int& ra = a;
比较一下两个变量的地址是否相同;
//比较二者的地址
cout << &a << endl;
cout << &ra << endl;
2.引用的性质
1.引用变量的类型与引用实体的类型要相同;
int a = 0;
int& ra = a;
char ch = 'a';
char& rch = ch;
2.引用在定义时必须初始化;
int a = 0;
int& ra = a;
//int& ra; //错误的写法
3.一个变量可以有多个引用;
int a = 0;
int& b = a;
int& c = a;
//...
4.引用变量只能引用一个实体。
int a = 0;
int b = 0;
int& ra = a;
ra = b; //不能再引用其他变量
//对比指针
int* pa = &a;
pa = &b;
3.常量引用
引用常量时记得用 const 修饰,因为指针、引用在赋值或初始化时,权限可以缩小不能放大。
//1.
const int a = 0;
//int& ra = a; //编译时会报错,a为常量//权限放大
const int& ra = a; //权限保持
//int& b = 10; //错误写法,10为常量//权限放大
int c = 0;
const int& rc = c; //权限缩小
//2.
int Count()
{
int a = 0;
return a + 1;
}
int main()
{
//int& ret = Count(); //编译错误,Count 返回值为常量
const int& ret = Count();
return 0;
}
//3.
int a = 0;
//double& b = a; //类型错误
//double& b = (double)a; //编译错误,类型转换时会产生临时变量
const double& b = (double)a; //证明产生的临时变量具有常量性质
4.使用场景
目前看来,引用好像并没有什么用,接下来看一下引用经常用到的场景。
1.作参数
//形参的改变会影响实参,因为形参为实参的别名
void Swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
//对比指针
void Swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
//顺序表
typedef struct SeqList
{
int* a;
int size;
int capacity;
}SL;
void SLPushBack(SL* ps, int data);//C语言中
void SLpushBack(SL& rs, int data);//C++中
//单链表
typedef struct Node
{
int data;
struct Node* next;
}Node,*PNode;
void SLTPushBack(Node** pphead, int data);//C语言中
void SLTPushBack(Node*& phead, int data);//C++中
void SLTPushBack(PNode& phead, int data);//C++中
2.作返回值
引用作返回值时,如果函数返回时,出了函数作用域,如果返回对象还在(还没还给系统),则可以使用引用返回,如果已经还给系统了,则必须使用传值返回。
int& Count()
{
static int n = 0;//出了作用域并未销毁,可用引用返回
n++;
return n;
}
int& Add(int a, int b)
{
int c = a + b;//c出了作用域会被销毁,引用返回不可用
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :" << ret << endl;//看似结果为3,实则不然
return 0;
}
引用作函数返回值时,调用函数时可修改返回对象;
#include<assert.h>
#define N 10
typedef struct Array {
int a[N];
int size = N;
}Array;
int& Test(Array& a, int i)
{
assert(i < N);
return a.a[i];
}
int main()
{
Array a;
for (int i = 0; i < N; i++)
{
Test(a, i) = i * 10;
}
for (int i = 0; i < N; i++)
{
cout << Test(a, i) << " ";
}
cout << endl;
return 0;
}
5.传值与传引用的效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低。
//一组测试代码
#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();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
return 0;
}
6.值和引用作为返回值的性能比较
//一组测试代码
#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();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
TestReturnByRefOrValue();
return 0;
}
7.引用与指针
引用与指针的用法及原理在我们使用者看来是不相同的(引用是给变量取别名,指针是指向变量的地址),但是其实引用的底层实现就是以指针的方式实现的。例如:
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
对比一下指针与引用的汇编代码,发现二者完全相同。
那么既然底层实现相同,我们是不是就不用区别引用和指针了呢?当然不是,底层实现相同可不关咱们使用者什么事,在使用时我们依旧要注意二者的区别。
指针与引用的不同点
1. 引用概念上定义一个变量的别名,指针存储一个变量地址;
2. 引用在定义时必须初始化,指针没有要求;
3. 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体;
4. 没有 NULL 引用,但有 NULL 指针;
5. 在 sizeof 中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节);
6. 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小;
7. 有多级指针,但是没有多级引用;
8. 访问实体方式不同,指针需要显式解引用,引用编译器自己处理;文章来源:https://www.toymoban.com/news/detail-799894.html
9. 引用比指针使用起来相对更安全。文章来源地址https://www.toymoban.com/news/detail-799894.html
到了这里,关于C++修炼之练气期第五层——引用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!