C++参考
到目前为止，我们已经了解到C++支持两种类型的变量:
普通变量是包含某种类型的值的变量。例如，我们创建了一个int类型的变量，这意味着该变量可以容纳整数类型的值。
指针是一个变量，用于存储另一个变量的地址。可以取消引用以检索此指针指向的值。
C++支持另一个变量，即引用。它是一个变量，充当另一个变量的别名。
如何创建引用？
只需使用"＆"运算符即可创建引用。当我们创建一个变量时，它会占用一些内存位置。我们可以创建变量的引用；因此，我们可以使用变量名或引用访问原始变量。例如，
现在，我们创建上述变量的参考变量。
上面的语句意味着'ref'是'a'的引用变量，即，我们可以使用'ref'变量代替'a'变量。
C++提供了两种类型的引用:
对非常量值的引用
作为别名的引用
对非常量值的引用
可以通过对引用类型变量使用＆运算符来声明它。
#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"。如果我们在声明时未分配，则代码如下:
由于声明时未分配'a'，因此上面的代码将引发编译时错误。
输出
重新分配
无法重新分配意味着无法修改参考变量。
#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'的另一个名称。
输出
