C++ 引用

目前为止，我们已经了解到C++支持两种类型的变量:

普通变量是一个包含某种类型数值的变量。例如，我们创建了一个int类型的变量，即这个变量可以存储整型数值。
指针是一个存储另一个变量地址的变量。我们可以通过解引用来获取指针所指向的值。
还有另外一种变量，C++支持，即引用。它是作为另一个变量的别名而存在的变量。

如何创建引用

引用可以通过使用和号（&）操作符来创建。当我们创建一个变量时，它占据一定的内存位置。我们可以创建这个变量的引用，因此可以通过变量的名称或引用来访问原始变量。例如，

int a=10;

现在，我们创建了上述变量的引用变量。

int &ref=a;

上述语句表示’ref’是’a’的引用变量，即我们可以使用’ref’变量来替代’a’变量。

C++提供两种类型的引用

对非const值的引用
作为别名的引用

对非const值的引用

可以通过使用引用类型变量的&操作符来声明。

#include <iostream>
using namespace std;
int main()
{
int a=10;
int &value=a;
std::cout << value << std::endl;
return 0;
}

输出

引用别名

引用别名是指被引用的变量的另一个名称。

例如：

int a=10;   // 'a' is a variable.
int &b=a; // 'b' reference to a.
int &c=a; // 'c' reference to a.

让我们看一个简单的例子。

#include <iostream>
using namespace std;
int main()
{
int a=70; // variable initialization
int &b=a;
int &c=a;
std::cout << "Value of a is :" <<a<< std::endl;
std::cout << "Value of b is :" <<b<< std::endl;
std::cout << "Value of c is :" <<c<< std::endl;
return 0;}

在上面的代码中，我们创建了一个变量’a’，它包含一个值’70’。我们声明了两个引用变量，即’b’和’c’，它们都引用同一个变量’a’。因此，我们可以说变量’a’可以被变量’b’和’c’访问。

输出

 Value of a is :70 
Value of b is :70 
Value of c is :70

引用的属性

以下是引用的属性：

初始化

必须在声明时进行初始化。

#include <iostream>
using namespace std;
int main()
{
int a=10; // variable initialization
int &b=a; // b reference to a
std::cout << "value of a is " <<b<< std::endl;
return 0;
}

在上述代码中，我们创建了一个引用变量，即’b’。在声明时，将’a’变量赋值给’b’。如果在声明时没有赋值，则代码将如下所示：

int &b
&b=a;

上面的代码在声明的时候’a’没有被赋值，将会抛出编译时错误。

输出：

 value of a is 10

重新分配

不能被重新分配意味着引用变量不能被修改。

#include <iostream>
using namespace std;
int main()
{
int x=11; // variable initialization
int z=67;
int &y=x; // y reference to x
int &y=z; // y reference to z, but throws a compile-time error.
return 0;}

在上面的代码中，’y’ 引用变量引用了 ‘x’ 变量，然后 ‘z’ 被赋值给了 ‘y’。但是这个重新赋值对于引用变量来说是不可能的，所以它会在编译时期报错。

编译时期错误

main.cpp: In function 'int main()':
main.cpp:18:9: error: redeclaration of 'int& y'
int &y=z; // y reference to z, but throws a compile-time error.
^
main.cpp:17:9: note: 'int& y' previously declared here
int &y=x; // y reference to x
^

函数参数

引用也可以作为函数参数传递。它不会创建参数的副本，而是作为参数的别名。它可以提高性能，因为它不会创建参数的副本。

我们通过一个简单的例子来理解。

#include <iostream>
using namespace std;
int main()
{
int a=9; // variable initialization
int b=10; // variable initialization
swap(a, b); // function calling
std::cout << "value of a is :" <<a<< std::endl;
std::cout << "value of b is :" <<b<< std::endl;
return 0;
}
void swap(int &p, int &q) // function definition
{
int temp; // variable declaration
temp=p;
p=q;
q=temp;
}

在上面的代码中，我们交换了’a’和’b’的值。我们将变量’a’和’b’传递给swap()函数。在swap()函数中，’p’指的是’a’，’q’指的是’b’。当我们交换’p’和’q’的值时，意味着’a’和’b’的值也被交换了。

输出

 value of a is :10 
value of b is :9

引用作为快捷方式

借助引用，我们可以轻松访问嵌套的数据。

#include <iostream>
using namespace std;
struct profile
{
int id;
};
struct employee
{
profile p;
};
int main()
{
employee e;
int &ref=e.p.id;
ref=34;
std::cout << e.p.id << std::endl;
}

在上述代码中，我们试图访问员工的个人资料结构体中的’id’。通常，我们通过使用语句e.p.id来访问该成员，但是如果我们多次访问该成员，这将是一项繁琐的任务。为了避免这种情况，我们创建了一个引用变量ref，即’e.p.id’的另一个名称。

输出