本文小编为大家详细介绍“C++引用的特性是什么”，内容详细，步骤清晰，细节处理妥当，希望这篇“C++引用的特性是什么”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。
引用不是新定义一个变量，而是给已存在变量取了一个别名，语法理解上程序不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"
类型& 引用变量名(对象名) = 引用实体
int main()
{
//有一块空间a,后面给a取了三个别名b、c、d
int a = 10;
int& b = a;
int& c = a;
int& d = b;
//char& d = a;//err,引用类型和引用实体不是同类型(这里有争议————char a = b[int类型],留个悬念,下面会解答)
//会被修改
c = 20;
d = 30;
return 0;
}注意
引用类型必须和引用实体是同种类型
注意区分 ‘&’ 取地址符号
引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体
int main()
{
//int& e;//err
int a = 10;
int& b = a;
//这里指的是把c的值赋值于b
int c = 20;
b = c;
return 0;
}void TestConstRef()
{
const int a = 10;
//int& ra = a; //该语句编译时会出错，a为常量;由const int到int
const int& ra = a;//ok
int b = 20;
const int& c = b; //ok,由int到const int
//b可以改,c只能读不能写
b = 30;
//c = 30;//err
//b、c分别起的别名的权限可以是不变或缩小
int& d = b;//ok
//int& e = c//err
const int& e = c;//ok
//int& f = 10; // 该语句编译时会出错，b为常量
const int& g = 10;//ok
int h = 10;
double i = h;//ok
//double& j = h;//err
const double& j = h;//ok
//?为啥h能赋值给i了(隐式类型转换)，而给h起一个double类型的别名却不行————如果是仅仅是类型的问题那为啥加上const就行了？
//double i = h;并不是直接把h给i,而是在它们中间产生了一个临时变量(double类型、常量),并利用这个临时变量赋值
//也就是说const double& j = h;就意味着j不是直接变成h的别名,而是变成临时变量(doublde类型)的别名,但是这个临时变量是一个常量,这也解释了为啥需要加上const
}小结
1.我能否满足你变成别名的条件：可以不变或者缩小你读写的权限 (const int -> const int 或 int -> const int)，而不能放大你读写的权限 (const int -> int)
2.别名的意义可以改变，并不是每个别名都跟原名有一样的权限
3.不能给类型不同的变量起别名的真正原因不是类型不同，而是隐式类型转换后具有常性了
常引用的意义 (举例栈)
typedef struct Stack
{
int* a;
int top;
int capacity;
}ST;
void InitStack(ST& s)//传引用是为了形参的改变影响实参
{//...}
void PrintStack(const ST& s)//1.传引用是为了减少拷贝 2. 同时保护实参不会被修改
{//...}
void Test(const int& n)//即可以接收变量，也可以接收常量
{//...}
int main()
{
ST st;
InitStack(st);
//...
PrintStack(st);
int i = 10;
Test(i);
Test(20);
return 0;
}小结
1.函数传参如果想减少拷贝使用引用传参，如果函数中不改变这个参数最好使用 const 引用传参
2.const 引用的好处是保护实参，避免被误改，且它可以传普通对象也可以传 const 对象
void Swap1(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void Swap2(int& rx, int& ry)
{
int temp = rx;
rx = ry;
ry = temp;
}
int main()
{
int x = 3, y = 5;
Swap1(&x, &y);//C传参
Swap2(x, y);//C++传参
return 0;
}在 C++ 中形参变量的改变，要影响实参，可以用指针或者引用解决
意义：指针实现单链表尾插 || 引用实现单链表尾插
void SListPushBack(SLTNode*& phead, int x)
{
//这里phead的改变就是plist的改变
}
void TestSList2()
{
SLTNode* plist = NULL;
SListPushBack(plist, 1);
SListPushBack(plist, 2);
}有些书上喜欢这样写 (不推荐)
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SLTNode, *PSLTNode;
void SListPushBack(PSLTNode& phead, int x)
{
//...
}//传值返回
int Add(int a, int b)
{
int c = a + b;
return c;//需要拷贝
}
int main()
{
int ret = Add(1, 2);//ok, 3
Add(3, 4);
cout << "Add(1, 2) is :"<< ret <<endl;
return 0;
}Add 函数里的 return c; —— 传值返回，临时变量作返回值。如果比较小，通常是寄存器；如果比较大，会在 main 函数里开辟一块临时空间
怎么证明呢
int Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
//int& ret = Add(1, 2);//err
const int& ret = Add(1, 2);//ok, 3
Add(3, 4);
cout << "Add(1, 2) is :"<< ret <<endl;
return 0;
}从上面就可以验证 Add 函数的返回值是先存储在临时空间里的
//传引用返回
int& Add(int a, int b)
{
int c = a + b;
return c;//不需要拷贝
}
int main()
{
int ret = Add(1, 2);//err, 3
Add(3, 4);
cout << "Add(1, 2) is :"<< ret <<endl;
return 0;
}结果是不确定的，因为 Add 函数的返回值是 c 的别名，所以在赋给 ret 前，c 的值到底是 3 还是随机值，跟平台有关系 (具体是平台销毁栈帧时是否会清理栈帧空间)，所以这里的这种写法本身就是越界的 (越界抽查不一定报错)、错误的
发现这样也能跑，但诡异的是为啥 ret 是 7
//传引用返回
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);//err, 7
Add(3, 4);
cout << "Add(1, 2) is :"<< ret <<endl;
return 0;
}在上面我们在 VS 下运行，可以得出编译器并没有清理栈帧，那么这里进一步验证引用返回的危害
虽然能正常运行，但是它是有问题的
1.出了 TEST 函数的作用域，ret 变量会销毁，就不能引用返回
2. 出了 TEST 函数的作用域，ret 变量不会销毁，就可以引用返回
3.引用返回的价值是减少拷贝
观察并剖析以下代码
int main()int main()
{
int x = 3, y = 5;
int* p1 = &x;
int* p2 = &y;
int*& p3 = p1;
*p3 = 10;
p3 = p2;
return 0;
}
#include <time.h>#include<iostream>using namespace std;struct A { int a[10000]; };A a;void TestFunc1(A a) {}void TestFunc2(A& a) {}A TestFunc3() { return a; }A& TestFunc4() { return 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;}void TestReturnByRefOrValue(){// 以值作为函数的返回值类型size_t begin1 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc3();size_t end1 = clock();// 以引用作为函数的返回值类型size_t begin2 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc4();size_t end2 = clock();// 计算两个函数运算完成之后的时间cout << "TestFunc1 time:" << end1 - begin1 << endl;cout << "TestFunc2 time:" << end2 - begin2 << endl;}int main(){//传值、传引用效率比较TestRefAndValue();cout << "----------cut----------" << endl;//值和引用作为返回值类型的性能比较TestReturnByRefOrValue();return 0;}#include <time.h>
#include<iostream>
using namespace std;
struct A { int a[10000]; };
A a;
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
A TestFunc3() { return a; }
A& TestFunc4() { return 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;
}
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc3();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc4();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
//传值、传引用效率比较
TestRefAndValue();
cout << "----------cut----------" << endl;
//值和引用作为返回值类型的性能比较
TestReturnByRefOrValue();
return 0;
}以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低
引用就是一个别名，没有独立空间，和其引用实体共用同一块空间
指针变量是开辟一块空间，存储变量的地址
int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
int b = 20;
int* pb = &b;
cout<<"&b = "<<&b<<endl;
cout<<"&pb = "<<&pb<<endl;
return 0;
}引用和指针是一样的，因为引用是按照指针方式来实现的
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}这里我们对比一下 VS 下引用和指针的汇编代码可以看出来他俩是同根同源
引用和指针的不同点：
1、引用在定义时必须初始化，指针没有要求
2、引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
3 、没有 NULL 引用，但有 NULL 指针
4、在 sizeof 中含义不同：引用结果为引用类型的大小，与类型有关；但指针始终是地址空间所占字节个数 (32 位平台下占 4 个字节，64 位平台下占 8 个字节)，与类型无关
5、引用自加即引用的实体增加 1，与类型无关，指针自加即指针向后偏移一个类型的大小，与类型有关
6、有多级指针，但是没有多级引用
7、访问实体方式不同，指针需要解引用，引用编译器自己处理
8、引用比指针使用起来相对更安全，指针容易出现野指针、空指针等非法访问问题
读到这里，这篇“C++引用的特性是什么”文章已经介绍完毕，想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会，如果想了解更多相关内容的文章，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
