C语言中的引用是什么？

Question

我刚刚开始使用C++，遇到过一些参考资料，但还没有完全理解。

正如我读到的，引用是对象的替代名称。为什么要使用它而不是直接访问对象，因为对引用的任何操作都会直接反映在对象上......？

1. 为什么以及何时使用它们？
2. ist 是否像一个常量指针，每次使用时都会被引用......？

而且，它说

 double& dr = 1;  ----  says it is an error (some lavalue needed) 
 const double& cdr = 1;  ---- says it is ok. 

我没有正确理解它。所以请解释为什么会这样...

谢谢...:)

Answer 1

传递对函数的引用，然后让函数使用该引用几乎就像将指针传递给函数，然后让函数取消引用该指针一样。在许多情况下，机器代码实现是相同的。不过，还是存在一些差异，尤其是在内联扩展的函数的情况下。如果变量通过引用传递给内联函数，则编译器在扩展函数时通常能够替换变量本身（即使存储在机器寄存器中）。相比之下，如果获取变量的地址并将其作为指向函数的指针传递，然后取消引用它，则编译器不太可能找出该优化，除非它不仅确定这一点 - 至少对于一个特定的扩展函数——指针将始终指向该变量，但指针不会在其他任何地方使用（如果指针在其他地方使用，则该变量不能保存在寄存器中）。

Answer 2

引用的实用性在将参数传递给函数的上下文中最为明显。

即，

int a；

func 定义： void foo (int¶m) {param = 1;}

func 调用： foo(a);

“param”别名“a”的方式很干净，其意图很容易被该代码的读者以及编译器理解，当内联引用所需的任何额外内存分配时，编译器可能会进行优化。

Answer 3

double& dr = 1; // 1.0 would be more clear

无效，因为 1 被视为 const double 类型，因此如果您想要引用该变量，则需要引用 const double代码>所以

const double& dr = 1.0;

是正确的。

Answer 4

引用是代表它们引用的另一个对象的语言实体。非常量引用是左值，必须使用左值进行初始化。它们的用途如下：

int& x=condition ? array[1] : array[2];
int& y=condition ? array[0] : array[3];
x+=y;
y=0;

当用作函数参数时，它们告诉调用者必须传递一个可能由函数写入的左值：

void set1(int& x) { x=1; }

int foo;
set1(foo); // ok, foo is 1
set1(foo+1); // not OK, not lvalue

另一方面，常量引用可以绑定到右值。在函数参数中，它们通常用于避免过多的复制：

void niceness(std::string s); // the string would be copied by its copy-ctor
void niceness(const std::string& s); // the caller's string would be used

请注意，这可能会也可能不会产生更快的代码。

当在普通代码中使用 const 引用时，它们也可以绑定右值，并且 作为一条特殊规则，它们延长了所绑定对象的生命周期。这就是您在代码中看到的：

const double& d=1; // OK, bind a rvalue to a const-ref
double& d=1; // Bad, need lvalue

所有引用都是多态的，就像指针一样：

class A { virtual void f(); }
class B : public A { void f(); }

B b;
A& ar=b;
ar.f(); // calls B::f()

并且所有引用都是别名，就像指针一样：

int f(int& a, const int& b)
{
  a=1;
  return b;
}

int x;
f(x, 42); // ==42, foo=1
x=42;
f(x, x); // ==1 (not 42), foo=1

Answer 5

仔细阅读维基百科文章。总而言之，引用是指针的更友好版本，通常用于将对象作为引用传递到函数中，而不必担心空指针。

解释这个例子：

---

将数字1想象为一个变量。编译时，该数字被放入内存的全局部分，程序可以引用它，但不修改。

所以它的类型是： const int

double &dr = 1 正在尝试分配 dr （对 double<的 引用/strong>) 到 const int 1。由于 1 是一个常量，编译器不允许您对其进行非常量引用。

在第二行中：

const double &dr = 1 尝试将 dr（对 double 的常量引用）分配给 常量 int 1。这是可行的，因为引用也是const，因此可以指向const int。

编辑
const int 在分配之前会转换为 const double。

Answer 6

引用改进了语法，因此不需要指针取消引用。
假设 Base 是一个可能派生自的类：

void someFunction(Base b)
{
    b.function();
    // b is a copy of what was passed - probably performance issues
    // possible unintended object slicing - you only get the Base part of it
    // no virtual function call
    // no changes to b visible outside the function
}

void someFunction(Base* b)
{
    b->function();
    // a shortcut for (*b).function();
    // b is the same object that was passed to the function
    // possible virtual call
    // changes visible outside the function
}

void someFunction(Base& b)
{
    b.function();
    // b is the same object that was passed to the function
    // possible virtual call
    // changes visible outside the function
}

引用就像常量指针（不是指向常量的指针 - 即您可以更改对象，但不能更改您所指向的内容）。 const 引用是一个引用，通过它你可以做 const 对象可以做的事情。

引用也很好，因为不能有空引用

Answer 7

我同意你的看法。仅使用引用作为别名并不是很有用。
如果您将其视为不可变指针，则会更有用。但实际上没那么有用。

实际上，它用于定义干净的接口。例如，当您定义：

int foo(const int& param);

您说 param 是 foo 中的只读参数。

不要忘记您必须为引用分配一个值。

的信息，请参阅 C++ faqlite

有关更多my2c

Answer 8

引用基本上是一个看起来像对象的指针。尽管您可以费尽心思创建一个 NULL 引用，但获得 NULL 引用是非常非常困难的。

对于您的示例，1 是右值或结果。它只是一个临时变量，无法修改。因此你不能对它进行非常量引用。但是您可以对其进行常量引用。这意味着您无法更改引用的值。

下面是创建 NULL 引用的示例。不要这样做！

int * x = (int *)NULL;
int & y = *x;

Answer 9

引用是最初在 C 代码中的另一种方式，就像这样

void fubarSquare(int *x){
  int y = *x;
  *x = y * y;
}

// typical invocation
int z = 2;
fubarSquare(&z);
// now z is 4

，在 C++ 中的引用则像这样 这

void fubarSquareCpp(int& x){
   x = x * x;
}

// typical invocation
int z = 2;
fubarSquareCpp(z);
// now z is 4

是一种使用按引用调用参数而不是使用 C 星号表示法的更简洁的语法方式/star 表示指针并作为按引用调用参数...以及直接在函数外部修改参数...

看看 Bjarne Stoustrap 的此处页面介绍了 C++ 的原理以及技术常见问题解答< a href="http://www2.research.att.com/~bs/bs_faq2.html" rel="nofollow noreferrer">此处

Answer 10

为什么使用它而不是直接使用它
作为任何操作访问对象
参考文献直接反映在
物体...？

C++ 按值传递参数，这意味着如果您有一个函数，例如：

void foo(MyObject o) { ... }

默认情况下，C++ 将复制 MyObject，不会直接使用传入的对象。所以，引用的一种用途是确保您正在处理同一个对象：

void foo(MyObject &o) { ...}

或者，如果您不修改 o：

void foo(const MyObject &o) { ... }