blocks|key|1950494|text|引用基本上是一个看起来像对象的指针。获得一个空引用非常困难，尽管您可以通过循环创建一个引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1950495|关于您的示例，1是一个rvalue或一个结果。它只是一个临时变量，不能修改。因此，您不能接受非const引用。但是，您可以对其进行const引用。这意味着您不能更改引用的值。|1950496|下面是一个创建空引用的示例。别这么做！|1950497|int+*+x+=+(int+*)NULL;
int+&+y+=+*x;|code-block|syntax|javascript|1950498|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A reference is basically a pointer that looks like an object. It is very very hard to get a NULL reference though you can go through hoops and create one.

With regards to your example, 1 is an rvalue or a result. It is just a temporary variable and can not be modified. Thus you can't take a non const reference to it. However you can take a const reference to it. This means you can't change the value of the reference.

Here is an example of creating a NULL reference. Don't do it!

<pre><code>int * x = (int *)NULL;
int &amp; y = *x;
</code></pre>

blocks|key|1950523|text|double&+dr+=+1;+//+1.0+would+be+more+clear|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1950524|无效，因为1被视为const+double类型，因此，如果您希望引用该变量，则需要引用const+double|unstyled|offset|length|style|CODE|1950525|const+double&+dr+=+1.0;|1950526|是对的。|1950527|entityMap^0|0|5|1|9|C|17|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@$G|S|H|T|I|J]|$G|U|H|V|I|J]|$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|10|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>double&amp; dr = 1; // 1.0 would be more clear
</code></pre>

Is invalid because <code>1</code> is viewed to be of type <code>const double</code> so if you want a reference to that variable you need to have a reference to a <code>const double</code> so

<pre><code>const double&amp; dr = 1.0;
</code></pre>

Is correct.

blocks|key|1950549|text|赞成。仅仅使用引用作为别名并不是很有用。如果您认为它是一个不可变的指针，它会更有用。但实际上没那么有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1950550|实际上，它用于定义干净的接口。例如，当您定义：|1950551|int+foo(const+int&+param);|code-block|syntax|javascript|1950552|您说param是foo中的只读参数。|1950553|不要忘记，您必须为引用赋值。|1950554|有关更多信息，请参见参考资料上的C%2B%2B辉石岩|offset|length|1950555|my2c|1950556|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/references.html^0|0|0|0|0|0|G|6|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$O|16|P|17|1|18]]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

I agree with you. using references as just an alias name is not very useful.
It is more useful if you consider it as an immutable pointer. But not that useful in fact.

Practically, it is used to define clean interfaces. For example when you define:

<pre><code>int foo(const int&amp; param);
</code></pre>

You say that param is a read-only parameter in foo.

Do not forget that you MUST assign a value to a reference.

See the <a href="http://www.parashift.com/c++-faq-lite/references.html" rel="nofollow noreferrer">C++ faqlite</a> on references for more

my2c

blocks|key|1595576|text|为什么要使用它而不是直接访问对象，因为引用上的任何操作都直接反映在对象上.？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1595577|C%2B%2B按值传递参数，这意味着如果您有如下函数：|unstyled|1595578|void+foo(MyObject+o)+{+...+}|code-block|syntax|javascript|1595579|默认情况下，C%2B%2B将复制一个MyObject，而不是直接使用传入的对象。因此，引用的一种用法是确保您正在处理同一个对象：|offset|length|style|CODE|1595580|void+foo(MyObject+&o)+{+...}|1595581|或者，如果您不修改o|1595582|void+foo(const+MyObject+&o)+{+...+}|1595583|entityMap^0|0|0|0|E|8|0|0|9|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|Z|8|@]|9|@]|A|$H|I]]|$1|J|3|K|5|D|7|10|8|@$L|11|M|12|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|G|7|13|8|@]|9|@]|A|$H|I]]|$1|R|3|S|5|D|7|14|8|@$L|15|M|16|N|O]]|9|@]|A|$]]|$1|T|3|U|5|G|7|17|8|@]|9|@]|A|$H|I]]|$1|V|3|-4|5|D|7|18|8|@]|9|@]|A|$]]]|W|$]]

<blockquote>
 Why use that instead of directly
 accessing the object as any operation
 on references is directly reflected on
 the object ...?
</blockquote>

C++ passes parameters by value, meaning if you have a function such as:

<pre><code>void foo(MyObject o) { ... }
</code></pre>

By default C++ will make a copy of a <code>MyObject</code>, not directly use the object being passed in. So, one use of references is to ensure you are working on the same object:

<pre><code>void foo(MyObject &amp;o) { ...}
</code></pre>

Or, if you aren't modifying <code>o</code>:

<pre><code>void foo(const MyObject &amp;o) { ... }
</code></pre>

blocks|key|398342|text|让维基百科文章通读一遍。总之，引用是更友好的指针版本，通常用于将对象作为引用传递到函数中，而无需担心空指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|398343|为了解释这个例子：|398344|想象一下1表示为变量的数字。在编译时，这个数字被放入内存的全局部分，程序可以引用该部分，但是没有修改。|style|CODE|BOLD|398345|所以它的类型是：const+int。|398346|double+&dr+=+1试图将dr+(对双的引用)分配给const+int+1。由于1是常量，编译器将不允许您对其进行非常量引用。|398347|在第二行：|398348|const+double+&dr+=+1正在尝试将dr+(对双的常量引用)分配给const+int+1。这是因为引用也是const，因此可以指向const+int。|398349|编辑+const+int在分配之前被转换为const+double。|398350|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Reference_(C%2B%2B)^0|1|4|0|0|0|4|1|1A|4|0|8|9|0|0|E|H|2|U|B|18|1|O|17|0|0|5|0|0|V|W|1E|0|K|P|2|14|B|20|9|0|0|2|3|V|3|9|L|C|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|17|8|@$A|18|B|19|H|I]|$A|1A|B|1B|H|J]]|9|@]|C|$]]|$1|K|3|L|5|6|7|1C|8|@$A|1D|B|1E|H|J]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1F|8|@$A|1G|B|1H|H|I]|$A|1I|B|1J|H|I]|$A|1K|B|1L|H|I]|$A|1M|B|1N|H|I]|$A|1O|B|1P|H|J]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1Q|8|@$A|1R|B|1S|H|J]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1T|8|@$A|1U|B|1V|H|J]|$A|1W|B|1X|H|J]|$A|1Y|B|1Z|H|I]|$A|20|B|21|H|I]|$A|22|B|23|H|I]|$A|24|B|25|H|I]]|9|@]|C|$]]|$1|S|3|T|5|6|7|26|8|@$A|27|B|28|H|J]|$A|29|B|2A|H|J]|$A|2B|B|2C|H|I]|$A|2D|B|2E|H|I]]|9|@]|C|$]]|$1|U|3|-4|5|6|7|2F|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

Give the <a href="http://en.wikipedia.org/wiki/Reference_(C%2B%2B)" rel="nofollow noreferrer">wikipedia</a> article a good read through. To sum it up, references are more friendly version of pointers which are commonly used to pass objects as references into functions without worrying about a null pointer. 

<h2>To explain the example:</h2>

<hr>

Think of the number <code>1</code> represented as a variable. When compiled, this number is put into the global section of the memory which can be referenced by the program, but not modified.

So it is of type: const int

<code>double &amp;dr = 1</code> is trying to assign <code>dr</code> (a reference to a double) to the <code>const int 1</code>. Since <code>1</code> is a constant, the compiler will not allow you to make a non-constant reference to it.

In the second line:

<code>const double &amp;dr = 1</code> is trying to assign <code>dr</code> (a constant reference to a double) the <code>const int 1</code>. This works because the reference is also const and therefore can point to a <code>const int</code>.

EDIT
The <code>const int</code> is converted to a <code>const double</code> before assigned.

blocks|key|1595679|text|引用改进了语法，因此不需要指针取消引用。假设Base是一个类，它可以派生于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1595680|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
}|code-block|syntax|javascript|1595681|引用就像常量指针(不是指向常量的指针--也就是说，可以更改对象，但不能更改指向的对象)。const引用是一种引用，您可以通过该引用对const对象进行操作。|1595682|引用也很好，因为不能有空引用|1595683|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

References improve the syntax, so no pointer dereference needed.
Assuming Base is a class that may be derived from:

<pre><code>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-&gt;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&amp; b)
{
 b.function();
 // b is the same object that was passed to the function
 // possible virtual call
 // changes visible outside the function
}
</code></pre>

References are like constant pointers (NOT pointers to constants - i.e. you can change the object, but you can't change to what you're pointing). const reference is a reference through which you can do things that can be done on const object.

References are also good, because you can't have a null reference

blocks|key|398431|text|在将参数传递给函数的上下文中，引用的效用最明显。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|398432|也就是说，|398433|int+a；|398434|func定义:+void+(int&+param)+{param+=+1;}|398435|功能电话:+foo(a)；|398436|作为'param‘别名'a’的方式是清晰的，它的意图很容易被这段代码的读者和编译器理解，而编译器可能在插入引用所需的任何额外内存分配时进行优化。|398437|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Utility of references is most visible in the context of passing parameters to functions.

I.e,

int a;

func definition: void foo (int&amp; param) {param = 1;}

func call: foo(a);

The way as 'param' aliases 'a' is clean and its intention is easily understood by a reader of this code as well as compiler that may optimize away when inlining any additional memory allocation needed for the reference.

blocks|key|1595758|text|引用是表示它们所引用的另一个对象的语言实体。非lvalue引用是lvalue，必须用lvalue初始化。它们可以像这样有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1595759|int&+x=condition+?+array[1]+:+array[2];
int&+y=condition+?+array[0]+:+array[3];
x%2B=y;
y=0;|code-block|syntax|javascript|1595760|当用作函数参数时，它们告诉调用者他必须传递一个可能被函数写入的lvalue：|1595761|void+set1(int&+x)+{+x=1;+}

int+foo;
set1(foo);+//+ok,+foo+is+1
set1(foo%2B1);+//+not+OK,+not+lvalue|1595762|另一方面，Const引用可以绑定到rvalue。在函数参数中，它们通常用于避免过多的副本：|1595763|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|1595764|请注意，这可能产生也可能不会产生更快的代码。|1595765|当在普通代码中使用const-引用时，它们也可以绑定rvalue和作为一种特殊的规则，它们延长了它们所绑定对象的生存期。。这就是您在代码中看到的：|offset|length|1595766|const+double&+d=1;+//+OK,+bind+a+rvalue+to+a+const-ref
double&+d=1;+//+Bad,+need+lvalue|1595767|所有引用都是多态的，就像指针一样：|1595768|class+A+{+virtual+void+f();+}
class+B+:+public+A+{+void+f();+}

B+b;
A&+ar=b;
ar.f();+//+calls+B::f()|1595769|所有引用都是像指针一样的别名：|1595770|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|1595771|entityMap|0|LINK|mutability|MUTABLE|url|http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/^0|0|0|0|0|0|0|0|X|R|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@$S|1K|T|1L|1|1M]]|A|$]]|$1|U|3|V|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|14|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B]]]]

References are language entitities that represent another object they refer to. Nonconst references are lvalues, and must be initialized with an lvalue. They can be useful like this:

<pre><code>int&amp; x=condition ? array[1] : array[2];
int&amp; y=condition ? array[0] : array[3];
x+=y;
y=0;
</code></pre>

When used as a function parameter, they tell the caller he has to pass an lvalue that might be written to by the function:

<pre><code>void set1(int&amp; x) { x=1; }

int foo;
set1(foo); // ok, foo is 1
set1(foo+1); // not OK, not lvalue
</code></pre>

Const references, on the other hand, can be bound to rvalues. In function parameters, they are usually used to avoid excessive copies:

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

Note that this may or may not yield faster code.

When const-references are used in normal code, they can bind rvalues, too, and <a href="http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/" rel="nofollow noreferrer">as a special rule, they extend the lifetime of the object they are bound to</a>. This is what you saw in your code:

<pre><code>const double&amp; d=1; // OK, bind a rvalue to a const-ref
double&amp; d=1; // Bad, need lvalue
</code></pre>

All references are polymorphic, like pointers:

<pre><code>class A { virtual void f(); }
class B : public A { void f(); }

B b;
A&amp; ar=b;
ar.f(); // calls B::f()
</code></pre>

and all references are aliases like pointers:

<pre><code>int f(int&amp; a, const int&amp; b)
{
 a=1;
 return b;
}

int x;
f(x, 42); // ==42, foo=1
x=42;
f(x, x); // ==1 (not 42), foo=1
</code></pre>

blocks|key|1595792|text|传递对函数的引用，然后让函数使用该引用，几乎就像传递指向函数的指针，然后使函数取消引用指针一样。在许多情况下，机器代码实现将是相同的。尽管如此，还是有一些不同之处，尤其是在函数进行内联扩展的情况下。如果通过引用内联函数传递变量，编译器在扩展函数时通常能够替换变量本身--即使存储在机器寄存器中。相反，如果取变量的地址并将其作为指向函数的指针传递给函数，则编译器不太可能计算出这种优化，除非编译器不仅确定--至少对于函数的一个特定扩展--指针将始终指向该变量，而且指针不会在其他任何地方使用(如果指针在其他地方使用，则变量不能保存在寄存器中)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1595793|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Passing a reference to a function and then having the function use the reference is almost like passing a pointer to the function and then having the function dereference the pointer. In many cases, the machine-code implementation will be identical. There are some differences, though, especially in the case of functions that get expanded inline. If a variable is passed by reference to an inline function, the compiler will often be able to substitute the variable itself--even if stored in a machine register--when expanding the function. By contrast, if one takes the address of a variable and passes that as a pointer to a function which then dereferences it, the compiler is less likely to figure out that optimization unless it determines not only that--at least for one particular expansion of the function--the pointer will always point to that variable, but also that the pointer will not be used anywhere else (if the pointer was used elsewhere, the variable could not be kept in a register).

I have just started C++ and have come across references and have not understood completely.

References , as i read is an alternative name for an object.Why use that instead of directly accessing the object as any operation on references is directly reflected on the object ...?

<ol>
<li>Why and when are they used ?</li>
<li>Is ist like a constant pointer that is referenced each time it is used ... ?</li>
</ol>

And , it says 

<pre><code> double&amp; dr = 1; ---- says it is an error (some lavalue needed) 
 const double&amp; cdr = 1; ---- says it is ok. 
</code></pre>

i dont understand it properly..So please explain why it is so ...

Thank You...:)

What is a reference in C?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我刚刚开始使用C++，遇到了一些参考资料，而且还没有完全理解。引用，正如我所读到的，是object.Why使用的替代名称，而不是直接访问对象，因为引用上的任何操作都直接反映在对象上.？为什么和何时使用？ist是否像每次使用时引用的常量指针.？而且，上面说 double& dr = 1;  ----  says it i...

问什么是C中的引用？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是C中的引用？EN