C++ 中用 & 和 * 声明的函数参数的区别

Question

我输入了以下示例：

#include <iostream>
double f(double* x, double* y)
{
    std::cout << "val x: " << *x << "\n";
    std::cout << "val y: " << *y << "\n";
    return *x * *y;
}
double f2(double &x, double &y)
{
    std::cout << "val x: " << x << "\n";
    std::cout << "val y: " << y << "\n";
    return x * y;
}
int main()
{
    double a, b;
    a = 2;
    b = 3; 
    std::cout << f(&a, &b) << "\n";
    std::cout << f2(a, b) << "\n";
    return 0;
}   

在函数f 中，我将x 和y 声明为指针，我可以使用*x 获取它们的值。当调用f 时，我需要传递我传递的参数的地址，这就是我传递&a, &b 的原因。 f2是一样的，只是定义不同。

现在我的问题是：它们在内存管理方面真的相同吗？两者都不复制传递的值，而是传递引用？ 我想知道f2，因为我无法读出f2 中x 的地址，所以我知道更多关于f 中x 和y 的信息（我知道地址和值） .

提前致谢！

编辑：好的，谢谢，经过更多研究，我发现了一个非常有用的主题：

Pointer vs. Reference 还有一个指向 google 编码指南 http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Reference_Arguments 的链接，这很像 useful 我觉得（据我现在理解，这是一种主题品味的形式）要更清晰

Answer 1

这只是语法糖，以避免每次引用参数时都必须使用*。您仍然可以使用& 在f2 中拥有x 的地址。

Answer 2

f2 通过引用获取它的参数，这本质上是您传递的参数的别名。指针和引用的区别在于引用不能为 NULL。使用f，您需要将传递给指针的参数的地址（使用& 运算符）传递给指针，当您通过引用传递时，您只需传递参数并创建别名.

当您不打算更改函数内部的参数时，首选通过 const 引用 (const double& ref) 传递，而当您要更改它们时，请使用非 const 引用。

当您需要能够将NULL 传递给您的参数时，通常会使用指针，显然您需要在函数内部检查指针是否不是NULL，然后再使用它。

Answer 3

您应该能够在这两个函数中读取x 地址。

要在f2 中这样做，您当然必须在x 前面加上&，因为在那里，x 是对双精度的引用，并且您想要一个 地址。

引用和指针之间值得注意的区别是前者不能为NULL。您必须在提供指针时传递一些东西（有效），如果允许/明确定义传递 NULL，则必须在文档中指定。

另一个区别是可读性问题：使用引用而不是指针（如果可能）可以减少代码中 * 和 -> 的混乱。

Answer 4

另一个未提及的区别是您无法更改引用所指的内容。这与原始问题中显示的函数调用示例没有太大区别。

int X(10), Y(20);
int *pX = X;
int& rY = Y;

*pX = 15; // change value of X
rY = 25;  // change value of Y

pX = Y;   // pX now points to Y

rY 始终指向Y，不能移动。

引用不能用于像指针这样的简单数组的索引。

Answer 5

在我看来，函数的参数总是按值传递。传递int 很容易想象，传递double 只是更大，传递struct 或class 确实可能非常大。
但是传递一个指向某个东西的指针，嗯，你只是传递一个地址按值。（指针对于 CPU 来说通常是一个方便的大小，就像int。）
引用非常相似，当然我认为引用是一个指针，但使用语法糖使它看起来像它所引用的对象已通过值传递。

您也可以将引用视为const 指针，即：

int i;
int j;
int* p = &i;           // pointer to i
int* const cp = p;     // cp points to i, but cp cannot be modified
p = &j;                // OK - p is modified to point to j
*cp = 0;               // OK - i is overwritten
cp = &j;               // ERROR - cp cannot be modified

int& ri = i;           // ri refers to i
ri = 1;                // i is overwritten
ri = j;                // i is overwritten again
                       // Did you think ri might refer to j?

因此，指针确实是双倍时间：它本身就是一个值，但当您取消引用它时它也可以指向另一个值，例如：*p。
此外，拥有引用参数意味着您不能在函数的生命周期内让它们引用其他任何东西，因为没有办法表达这一点。

一个引用应该不能用null初始化，但考虑一下：

void foo(int& i);

int* p = 0;
foo(*p);

这意味着在使用它们之前应该检查指针，但不能检查引用。 foo() 的实现可能会尝试读取或写入 i，这将导致访问冲突。

在上面的例子中，指针p应该在用于foo的调用之前进行检查：

if (p) foo(*p);