blocks|key|1204245|text|最常见的情况是实现像operator[]这样的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204246|struct+A+{
++++int+data[10];
++++int+&+operator[](+int+i+)+{
+++++++++return+data[i];
++++}
};|code-block|syntax|javascript|1204247|另一种方法是通过accesor函数从类中返回一个大对象：|1204248|struct+b+{
++++SomeBigThing+big;
++++const+SomeBigThing+&+MyBig()+const+{
+++++++++return+big;
++++}
};|1204249|以避免复制开销。|1204250|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The commonest case is to implement things like operator[].

<pre><code>struct A {
 int data[10];
 int &amp; operator[]( int i ) {
 return data[i];
 }
};
</code></pre>

Another is to return a big object from a class via an accesor function:

<pre><code>struct b {
 SomeBigThing big;
 const SomeBigThing &amp; MyBig() const {
 return big;
 }
};
</code></pre>

in order to avoid the copying overhead.

blocks|key|989873|text|std::vector有operator[]，否则不允许使用vec[n]+=+m。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|989874|entityMap^0|0|B|C|A|U|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

<code>std::vector</code> has <code>operator[]</code> which would not allow <code>vec[n] = m</code> otherwise.

blocks|key|1204310|text|一个非常正常的用例是当你编写一个类似类的数组时。在这里，您希望重载operator+[]，这样就可以执行a[0]+=+10;，在这种情况下，您会希望签名类似于int&+operator[](int+index);|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1204311|entityMap^0|X|B|1G|A|27|R|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

A very normal use case is when you write an array like class. Here you want to overload the <code>operator []</code> so as you can do <code>a[0] = 10;</code> In that case you would want the signature to be like <code>int&amp; operator[](int index);</code>

blocks|key|1204321|text|例如，Getters/setters|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204322|class+C
{
++++int+some_param_;
public:
++++int&+param()+{+return+some_param_;+}
++++int+const&+param()+const+{+return+some_param_;+}
};|code-block|syntax|javascript|1204323|但是在这里，你应该使用some_param作为一个公共整型。容器提供了通过引用返回的函数，例如。这样你就可以编写v[k]+=+x了。|offset|length|style|CODE|1204324|entityMap^0|0|0|1K|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Getters/setters for instance

<pre><code>class C
{
 int some_param_;
public:
 int&amp; param() { return some_param_; }
 int const&amp; param() const { return some_param_; }
};
</code></pre>

but here you should go with some_param being a public int. Containers provide functions that return by reference, eg. <code>vector&lt;T&gt;::operator[]</code> so that you can write <code>v[k] = x</code>.

blocks|key|1204338|text|在实现访问器时，它非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204339|class+Matrix
{
+++public:
++++++//I+skip+constructor,+destructor+etc

++++++int+&+operator+()(int+row,+int+col)
++++++{
+++++++++return+m_arr[row+%2B+col+*+size];
++++++}

+++private:
++++++int+size;
++++++int+*+m_arr;
}

Matrix+m(10);
m(1,0)+=+10;++//assign+a+value+to+row+1,+col+0|code-block|syntax|javascript|1204340|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It can be usefull when implementing accessors

<pre><code>class Matrix
{
 public:
 //I skip constructor, destructor etc

 int &amp; operator ()(int row, int col)
 {
 return m_arr[row + col * size];
 }

 private:
 int size;
 int * m_arr;
}

Matrix m(10);
m(1,0) = 10; //assign a value to row 1, col 0
</code></pre>

blocks|key|1204413|text|考虑下面的代码，MyFunction返回一个指向整型的指针，然后将一个值设置为整型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204414|int++*i;
i+=+MyFunction();
*i+=+10;|code-block|syntax|javascript|1204415|现在将其缩短为|1204416|*(MyFunction())+=+10;|1204417|它做的事情和第一个代码块完全一样。|1204418|你可以把一个引用看作是一个总是被取消引用的指针。因此，如果我的函数返回一个指向int的引用--而不是一个指针--第一个代码块将变成|1204419|int++&i;
i+=+MyFunction();
i+=+10;|1204420|第二个就会变成|1204421|MyFunction()+=+10;|1204422|这就是我要找的|1204423|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

Consider the following code, MyFunction returns a pointer to an int, and you set a value to the int.

<pre><code>int *i;
i = MyFunction();
*i = 10;
</code></pre>

Now shorten that to

<pre><code>*(MyFunction()) = 10;
</code></pre>

It does exactly the same thing as the first code block.

You can look at a reference as just a pointer that's always dereferenced. So if my function returned a reference - not a pointer - to an int the frist code block would become

<pre><code>int &amp;i;
i = MyFunction();
i = 10;
</code></pre>

and the second would become

<pre><code>MyFunction() = 10;
</code></pre>

This is what i was looking for

blocks|key|1204437|text|另一个经典案例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204438|class+Foo+{
++Foo();
public:
++static+Foo&+getSingleton();
};|code-block|syntax|javascript|1204439|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another classic case:

<pre><code>class Foo {
 Foo();
public:
 static Foo&amp; getSingleton();
};
</code></pre>

blocks|key|1204513|text|你也可以使用return+by+reference来实现方法链接(如果你愿意的话)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1204514|class+A
{
public:
++++A&+method1()
++++{
++++++++//do+something
++++++++return+*this;+++//return+ref+to+the+current+object
++++}
++++A&+method2(int+i);
++++A&+method3(float+f);++//other+bodies+omitted+for+brevity
};

int+main()
{
++++A+aObj;
++++aObj.method1().method2(5).method3(0.75);

++++//or+use+it+like+this,+if+you+prefer
++++aObj.method1()
++++++++.method2(5)
++++++++.method3(0.75);
}|code-block|syntax|javascript|1204515|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also achieve method chaining (if you so desire) using return by reference.

<pre><code>class A
{
public:
 A&amp; method1()
 {
 //do something
 return *this; //return ref to the current object
 }
 A&amp; method2(int i);
 A&amp; method3(float f); //other bodies omitted for brevity
};

int main()
{
 A aObj;
 aObj.method1().method2(5).method3(0.75);

 //or use it like this, if you prefer
 aObj.method1()
 .method2(5)
 .method3(0.75);
}
</code></pre>

blocks|key|1204580|text|named+parameter+idiom是另一个用例。考虑一下|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1204581|class+Foo
{
public:
++++Foo(
++++++++int+lions,
++++++++float+tigers,
++++++++double+bears,
++++++++std::string+zookeeper
++++);
};|code-block|syntax|javascript|1204582|此类的用户需要记住每个参数的位置|1204583|Foo+foo(+1,+2.0,+5,+"Fred"+);|1204584|这在不看报头的情况下是不明显的。与下面这样的创建者类相比|1204585|class+CreateFoo
{
friend+class+Foo;
public:
++++CreateFoo();

++++CreateFoo&+lions(int+lions)+{
++++++++_lions+=+lions;
+++++++++return+*this;
++++}

++++CreateFoo&+tigers(float+tigers)+{
++++++++_tigers+=+tigers;
++++++++return+*this;
++++}

++++CreateFoo&+bears(double+bears)+{
++++++++_bears+=+bears;
++++++++return+*this;
++++}

++++CreateFoo&+zookeeper(const+std::string&+zookeeper)+{
++++++++_zookeeper+=+zookeeper;
++++++++return+*this;
++++}

private:
++++int+_lions;
++++float+_tigers;
++++double+_bears;
++++std::string+_zookeeper;
};|1204586|然后可以由客户端使用，如下所示|1204587|Foo+foo+=+CreateFoo().
++++lions(1).
++++tigers(2.0).
++++zookeeper("Fred").
++++bears(5)
++++;|1204588|假设Foo有一个接受const+CreateFoo&的构造函数。|style|CODE|1204589|entityMap|0|LINK|mutability|MUTABLE|url|http://www.parashift.com/c%2B%2B-faq-lite/ctors.html#faq-10.18^0|0|L|0|0|0|0|0|0|0|0|0|2|3|A|G|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1E|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|C|$]]|$1|S|3|T|5|F|7|1G|8|@]|9|@]|C|$G|H]]|$1|U|3|V|5|6|7|1H|8|@$A|1I|B|1J|W|X]|$A|1K|B|1L|W|X]]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]]]

The <a href="http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.18" rel="nofollow noreferrer">named parameter idiom</a> is a another use case. Consider

<pre><code>class Foo
{
public:
 Foo(
 int lions,
 float tigers,
 double bears,
 std::string zookeeper
 );
};
</code></pre>

users of this class need to remember the position of each parameter

<pre><code>Foo foo( 1, 2.0, 5, "Fred" );
</code></pre>

which can be non-obvious without looking at the header. Compared to a creator class like so

<pre><code>class CreateFoo
{
friend class Foo;
public:
 CreateFoo();

 CreateFoo&amp; lions(int lions) {
 _lions = lions;
 return *this;
 }

 CreateFoo&amp; tigers(float tigers) {
 _tigers = tigers;
 return *this;
 }

 CreateFoo&amp; bears(double bears) {
 _bears = bears;
 return *this;
 }

 CreateFoo&amp; zookeeper(const std::string&amp; zookeeper) {
 _zookeeper = zookeeper;
 return *this;
 }

private:
 int _lions;
 float _tigers;
 double _bears;
 std::string _zookeeper;
};
</code></pre>

which can then be used by clients like so

<pre><code>Foo foo = CreateFoo().
 lions(1).
 tigers(2.0).
 zookeeper("Fred").
 bears(5)
 ;
</code></pre>

assuming <code>Foo</code> has a constructor taking a <code>const CreateFoo&amp;</code>.

In C++,

<pre><code>function() = 10;
</code></pre>

works if the function returns a variable by reference.

What are the use cases of it?

Whats the significance of return by reference?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在C++中，function() = 10;如果函数通过引用返回变量，则此函数起作用。它的用例是什么？

问引用返回的意义是什么？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问引用返回的意义是什么？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问引用返回的意义是什么？
EN