它返回一个int的 reference。引用与指针类似，但有一些重要的区别。我建议你阅读指针，引用，对象和原始数据类型之间的区别。
“Effective C++”（ISBN 9780321334879）和“More Effective C++”（ISBN 9780201633719）都是Scott Meyers写的）对指针和引用的区别以及何时使用指针和引用有一些很好的描述。
编辑：有很多答案都是沿着“引用只是语法上的糖，方便指针的处理”这样的说法。
下面是一个例子：

int a = 3;
int b = 4;
int* pointerToA = &a;
int* pointerToB = &b;
int* p = pointerToA;
p = pointerToB;
printf("%d %d %d\n", a, b, *p); // Prints 3 4 4
int& referenceToA = a;
int& referenceToB = b;
int& r = referenceToA;
r = referenceToB;
printf("%d %d %d\n", a, b, r); // Prints 4 4 4

字符串
行p = pointerToB改变了p的值，也就是说，它现在指向不同的内存。
r = referenceToB做了完全不同的事情：它将b的值分配给a的值。它根本不会**改变r。r仍然是对同一块内存的引用。
区别很微妙，但非常重要。
如果你仍然认为引用只是指针处理的语法糖，那么请阅读Scott Meyers的书，他可以比我更好地解释两者的区别。

在这里要小心......你走的是C/C++路线。有一个相当清楚的区别，但它并不总是这样看：

C++：这通常意味着引用。例如，考虑：

void func(int &x)
{
   x = 4;
}

void callfunc()
{
    int x = 7;
    func(x);
}

字符串
因此，**C++**可以通过值传递或通过引用传递。
然而，C没有这种通过引用传递的功能。&表示“addressof”，是一种从变量构造指针的方法。但是，请考虑以下情况：

void func(int* x)
{
   *x = 4;
}

void callfunc()
{
    int x = 7;
    func(&x);
}

型
看似相似，但本质上不同。在C中，你所做的是传递指针的副本。现在这些东西仍然指向内存的同一个区域，所以就被指向的内存而言，效果就像是一个按引用传递，但它不是一个被传递的引用。它是对内存中某个点的引用。
请尝试以下操作（编译为C）：

#include <stdio.h>

void addptr(int* x)
{
    printf("Add-ptr scope 1:\n");
    printf("Addr: %p\n", x);
    printf("Pointed-to-memory: %d\n", *x);
    *x = *x + 7;
    x++;
    printf("Add-ptr scope 2:\n");
    printf("Addr: %p\n", x);
    printf("Pointed-to-memory: %d\n", *x);
}

int main(int argc, char** argv)
{
    int a = 7;
    int *y = &a;
    printf("Main-Scope 2:\n");
    printf("Addr: %p\n", y);
    printf("Pointed-to-memory: %d\n", *y);
    addptr(y);
    printf("Main-Scope 2:\n");
    printf("Addr: %p\n", y);
    printf("Pointed-to-memory: %d\n", *y);
    return 0;

}

型
如果C是通过引用传递的，那么当addptr改变了传入的指针地址时，它应该反映在main中，但是它没有。指针仍然是值。
所以，C没有任何通过引用传递的机制。在C中，这是存在的，这就是&在函数参数等中的含义。
编辑：您可能想知道为什么我不能轻松地用C来做这个演示。这是因为我根本不能更改引用的地址。来自this quite good guide to references：

如何重置引用以使其引用其他对象？

不会吧
你不能把参照物和被参照物分开。
与指针不同的是，一旦引用绑定到一个对象，它就不能被“重置”到另一个对象。引用本身不是一个对象（它没有标识;获取引用的地址会得到所指对象的地址;记住：引用就是它的所指对象）。
从这个意义上说，引用类似于一个常量指针，例如int* const p（而不是指向常量的指针，例如int const* p）。但是，请不要混淆引用和指针;从程序员的Angular 来看，它们是非常不同的。
根据请求，在返回参考时：

#include <iostream>

using namespace std;

int& function(int f)
{
   f=f+3;
   return f;
}

int main(int argc, char** argv)
{
    int x = 7;
    int y;
    y = function(x);
    cout << "Input: " << x << endl;
    cout << "Output:" << y << endl;
    return 0;
}

型
任何好的编译器都应该以某种形式给予以下警告消息：
exp.cpp：7：11：警告：传回与局部变量'f'相关的堆栈内存指涉
这意味着什么呢？我们知道函数的参数是被压入栈中的（注意：在x64上不是这样的，它们先进入寄存器，然后进入栈中，但在x86上是这样的），这个警告的意思是，创建一个对这样一个对象的引用并不是一个好主意，因为它不能保证被留在原处。事实上，这只是运气。
那么，是什么原因呢？试试这个修改后的版本：

#include <iostream>

using namespace std;

int& function(int& f)
{
    f=f+3;
    return f;
}

int main(int argc, char** argv)
{
    int x = 7;
    int y;
    y = function(x);
    cout << "Input: " << x << endl;
    cout << "Output:" << y << endl;
    return 0;
}

型
运行这个，你会看到两个值都被更新了。什么？它们都引用了同一个东西，那个东西正在被编辑。

它返回一个int变量的引用。

这个问题根本不是C/C++，因为C没有引用，只有指针。int&是对int的引用。另外，你不需要void，它可以是int& foo();

Alfred的评论
这是文档说的，Texas instrument's TMS320C28x C/C++ compiler intrinsics，第122页，int&__byte（int，unsigned int），我猜它和PC不一样- Alfred Zhong
从手册：
int &__byte（int *array，unsigned int byte_index）;
MOVB array[byte_index].LSB，src
C28 x中的最低可寻址单元是16位。因此，通常您无法访问内存位置的8位MOVB dst，array[byte_index]. LSB实体。此内在函数有助于访问内存位置的8位量，并且可以按如下方式调用：
__byte（array，5）= 10;
B = __byte（array，20）;
这只是意味着函数返回一个对一个整数的引用，它的作用就像一个8位的量。因为值是一个引用，修改将修改目标对象（就像MOVB）指令，而赋值给b将复制（就像MOVB）到目标。

我只是通过变量来告诉你

int i = 5;
int * pI = &i;
int & referenceToI = * pI;
referenceToI = 4; // now i == 4

字符串

编辑：引用只是一种语法上的糖，用来方便指针的处理。在汇编级，编译器生成的代码返回给你一个地址指针

https://isocpp.org/wiki/faq/references
这个页面说得很简洁！引用是一个别名。它是对象，只是用另一个名字。以前的名字仍然有效。引用不是一个独立的对象。它是一个不同名字的对象。你不能对引用进行操作，因为它本身不是一个东西。它只是原始对象的别名。
就是这么简单。现在你可以很容易地想到它，而不是在上面的帖子中一轮又一轮。

int&是一个引用。更准确地说，引用变量只是现有变量的替代名称。
示例：考虑下面的代码

main(){
    int x = 4;
    int& ref_of_x = x;
    // Now, modifying x modifies ref_of_x too and vice-versa
    x = 5;
    cout<<ref_of_x; //This prints 5
    
    ref_of_x = 15;
    cout<<x;  // This prints 15
    }

字符串