int & 是什么意思

Question

一个 C++ 问题，

我知道

int* foo(void)

foo 将返回一个指向 int 类型的指针

怎么样

int &foo(void)

它返回什么？

非常感谢！

Answer 1

它返回对 int 的引用。 引用类似于指针，但有一些重要的区别。 我建议您阅读指针、引用、对象和原始数据类型之间的区别。

“Effective C++”和“More Effective C++”（均由 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 的书籍。 他可以比我更好地解释差异。

Answer 2

在这里要小心……您正在走 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++ 中进行此演示。 这是因为我无法更改引用的地址。 完全没有。 从他相当好的参考指南：

如何重新设置引用以使其引用不同的对象？

没门。

您无法将引用与所指对象分开。

与指针不同，一旦引用绑定到一个对象，它就不能“重新定位”到另一个对象。 引用本身不是一个对象（它没有身份；获取引用的地址可以得到引用的地址；记住：引用是它的引用）。

从这个意义上说，引用类似于 const 指针，例如 int* const p（与指向 const 的指针，例如 int const* p 不同）。 但请不要将引用与指针混淆； 从程序员的角度来看，它们非常不同。

根据要求，在返回参考资料时：

#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;
}

运行这个，你会看到两个值都更新了。 什么？ 好吧，他们都指的是同一件事，而那件事正在被编辑。

Answer 3

它返回对 int 变量的引用。

Answer 4

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

Answer 5

来自阿尔弗雷德的评论

文档是这么说的，德州仪器的 TMS320C28x C/C++ 编译器内在函数，第 122 页，int&__byte(int, unsigned int)，我猜它和 PC 不一样 – Alfred Zhong

从手册：

int &__byte(int *array, unsigned int byte_index);

MOVB 数组[byte_index].LSB, src

C28x 中的最低可寻址单元是 16 位。 因此，通常不能访问 8 位 MOVB dst, array[byte_index]。 LSB 实体离开内存位置。 此内在函数有助于访问内存位置的 8 位数量，并且可以按如下方式调用：

__byte(array,5) = 10;
b = __byte(array,20);

这只是意味着该函数返回对一个整数的引用，该整数的作用类似于 8 位量。 因为值是一个引用，修改将修改目标处的对象（就像 MOVB）指令，而分配给 b 将复制（就像 MOVB）到目标。

Answer 6

只是玩变量来向您展示含义

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

编辑：引用只是更容易处理指针的语法糖。 在汇编级别，编译器生成的代码返回给你一个地址指针

Answer 7

https://isocpp.org/wiki/faq/references

这一页说的很简洁！ 引用是别名。 它是对象，只是另一个名称。 以前的名称仍然有效。 引用不是独立对象。 它是不同名称的对象。 您不能对引用进行操作，因为它本身不是事物。 它只是原始对象的别名。

就是这么简单。 现在您可以轻松地想到它，而不是上面的帖子中的一轮又一轮。

Answer 8

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
    }