C+中的引用+； 我刚刚开始C++，遇到过引用，还没有完全理解。

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

为什么和何时使用它们

ist是否类似于每次使用时引用的常量指针 而且，它说

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

我不太明白，所以请解释一下为什么

---

谢谢……：）

引用基本上是一个看起来像对象的指针。虽然可以通过各种方法创建一个空引用，但是很难获得空引用

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

下面是一个创建空引用的示例。别这样

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

无效，因为

1

被视为

const double

类型，因此如果您希望引用该变量，则需要引用

const double

so

const double& dr = 1.0;

---

是正确的。

引用是最初在C代码中使用的另一种方式，如下所示

void fubarSquare(int *x){ int y = *x; *x = y * y; } // typical invocation int z = 2; fubarSquare(&z); // now z is 4 void fubarSquareCpp(int& x){ x = x * x; } // typical invocation int z = 2; fubarSquareCpp(z); // now z is 4 void fubarSquare（int*x）{ int y=*x； *x=y*y； } //典型调用 int z=2； 福巴尔广场； //现在z是4 <引用C++中的引用，将类似于

void fubarSquare(int *x){ int y = *x; *x = y * y; } // typical invocation int z = 2; fubarSquare(&z); // now z is 4 void fubarSquareCpp(int& x){ x = x * x; } // typical invocation int z = 2; fubarSquareCpp(z); // now z is 4 void fubarSquareCpp（int&x）{ x=x*x； } //典型调用 int z=2； fubarSquareCpp（z）； //现在z是4 这是一种更简洁的语法方法，使用引用调用参数，而不是使用C的符号星号/星来表示指针，并作为引用调用参数…和直接在函数外部修改参数

---

请看Bjarne Stoustrap的页面，它涵盖C++是什么，这里也是技术FAQ

< P>我同意你的观点。使用引用作为别名不是很有用。 如果你认为它是一个不变的指针，它会更有用。但事实上没那么有用

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

int foo(const int& param);

您说param是foo中的只读参数

不要忘记，必须为引用指定一个值

有关更多信息，请参阅参考资料中的

my2c

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

C++按值传递参数，这意味着如果您具有以下函数：

void foo(MyObject o) { ... }

默认C++将复制<代码> MyObjult<代码>，而不是直接使用传入的对象。因此，引用的一个用途是确保您在处理同一对象：

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

或者，如果您没有修改

o

：

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

把这篇文章通读一遍。总之，引用是指针的更友好版本，通常用于将对象作为引用传递到函数中，而不必担心空指针

要解释该示例，请执行以下操作：

---

把数字

1

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

所以它的类型是：const int

double&dr=1

正在尝试将

dr

（对double的引用）分配给

常量int 1

。由于

1

是一个常量，编译器将不允许您对其进行非常量引用

在第二行：

constdouble&dr=1

正在尝试将

dr

（一个常量引用到一个double）分配给

constint1

。这是因为引用也是const，因此可以指向

const int

编辑

---

const int

在赋值之前转换为

const double

。

引用改进了语法，因此不需要取消指针引用。 假设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 reference是一种引用，通过它，您可以在const对象上执行可以执行的操作

---

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

引用的实用程序在向函数传递参数的上下文中最为可见

即

INTA

func定义：void foo（int¶m）{param=1；}

func call:foo（a）

---

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

引用是表示它们引用的另一个对象的语言实体。非ST引用是左值，必须用左值初始化。它们可以像这样有用：

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 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

所有引用都是类似指针的别名：

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

---

将引用传递给函数，然后让函数使用引用，这几乎就像将指针传递给函数，然后让函数取消引用指针一样。在许多情况下，机器代码实现是相同的。这里有