blocks|key|2862246|text|在上一个示例中，arg是一个右值引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2862247|2862248|转发引用是对cv未限定模板参数的右值引用|blockquote|2862249|2862250|2862251|并且Tuple<Ts...>不是模板参数。|2862252|(引用自temp.deduct.call。)|2862253|entityMap^0|8|3|0|0|0|0|0|2|C|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|U|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|V|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|X|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|11|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|Q|$]]

In your last example, <code>arg</code> is an rvalue reference.

<blockquote>
 A forwarding reference is an rvalue reference to a cv-unqualified template parameter
</blockquote>

and <code>Tuple&lt;Ts...&gt;</code> is not a template parameter.

(Citation from [temp.deduct.call].)

blocks|key|2650932|text|它是一个右值引用，而不是转发引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2650933|确保的最简单方法是尝试传递一个左值，如果失败，则它是一个右值引用，如果不是，则是一个转发引用：|2650934|template<typename...+Ts>
struct+foo+{};

//f+function+definition

int+main()+{
++++foo<int,+double>+bar;
++++f(bar);+//+fails!+Cannot+bind+lvalue+to+rvalue+reference
++++f(foo<int,+double>{});+//+ok,+rvalue+is+passed
}|code-block|syntax|javascript|2650935|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It is a rvalue reference, not a forwarding reference.

The easiest way to be sure is to try to pass an lvalue, if it fails, then it is a rvalue reference, if not, then a forwarding reference:

<pre><code>template&lt;typename... Ts&gt;
struct foo {};

//f function definition

int main() {
 foo&lt;int, double&gt; bar;
 f(bar); // fails! Cannot bind lvalue to rvalue reference
 f(foo&lt;int, double&gt;{}); // ok, rvalue is passed
}
</code></pre>

blocks|key|107733|text|概念转发引用不是一个标准的概念，当你看到它时，它是很有用的，但如果你想正确地理解和处理它，你必须理解引用算法。(我相信Meyer的书中也有关于这一点的章节)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|107734|转发引用的概念背后是引用算法：|107735|107736|&=+&&+|unordered-list-item|107737|&=+&|107738|&+=+&|107739|+&+&+=+&|107740|107741|让我们用一个转发引用来模拟编译器模板类型推导|107742|template<class+T>
void+foo(T&&);
//...
const+int+i=42;
foo(i);+//+the+compiler+will+defines+T+=+const+int+&
+++++++++//++++++++++T&&++=+const+int+&+&&+=+const+int+&
+++++++++//+=>+the+compiler+instantiates+void+foo<const+int+&>(const+int+&);
foo(6*7);//+the+compiler+will+defines+T+=+int
+++++++++//++++++++++T&&++=+int+&&
+++++++++//+the+compiler+instantiates++void+foo<int>(int+&&);|code-block|syntax|javascript|107743|在这种情况下，模板foo的实例化可以产生通过左值引用接受参数的函数或接受参数右值引用的函数:转发引用是右值引用还是左值引用，这取决于模板类型推断。它的名称是这样的，因为在这种情况下，参数应该作为左值或x值传递，而这是T&&+std::forward<T>(T&&+a)的工作|offset|length|style|CODE|107744|如果你声明一个函数有：|107745|+template<class+T>
+void+foo(ATemplateClass<T>+&&+a);|107746|无论编译器为T推导出什么类型，你都会得到一个右值引用参数。|107747|entityMap^0|0|0|0|0|0|0|0|0|0|0|30|Q|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|1C|8|@]|9|@]|A|$]]|$1|H|3|I|5|G|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|G|7|1E|8|@]|9|@]|A|$]]|$1|L|3|M|5|G|7|1F|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1I|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1J|8|@$X|1K|Y|1L|Z|10]]|9|@]|A|$]]|$1|11|3|12|5|6|7|1M|8|@]|9|@]|A|$]]|$1|13|3|14|5|S|7|1N|8|@]|9|@]|A|$T|U]]|$1|15|3|16|5|6|7|1O|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|18|$]]

The concept forwarding reference is not a standard concept, it is usefull de recognize it when you see it, but if you want to understand and deal with it correctly you must understand reference arithmetics. (I believe Meyer's book has also a chapter about it)

What is behind the concept of a forwarding reference is the reference arithmetic:

<ul>
<li>&amp;&amp; &amp;&amp; = &amp;&amp;</li>
<li>&amp;&amp; &amp; = &amp;</li>
<li>&amp; &amp;&amp; = &amp;</li>
<li>&amp; &amp; = &amp;</li>
</ul>

Let's simulate compiler template type deduction with a forwarding reference

<pre><code>template&lt;class T&gt;
void foo(T&amp;&amp;);
//...
const int i=42;
foo(i); // the compiler will defines T = const int &amp;
 // T&amp;&amp; = const int &amp; &amp;&amp; = const int &amp;
 // =&gt; the compiler instantiates void foo&lt;const int &amp;&gt;(const int &amp;);
foo(6*7);// the compiler will defines T = int
 // T&amp;&amp; = int &amp;&amp;
 // the compiler instantiates void foo&lt;int&gt;(int &amp;&amp;);
</code></pre>

in such a situation, the instantiation of the template foo can produces
a function wich takes argument by lvalue reference or functions which takes arguments rvalue reference: a forwarding reference is either
a rvalue reference or a lvalue reference, depending on template type deduction. It is named like this, because in such a situation, the parameter shall be passed either as an lvalue or as an xvalue, and this is the job of <code>T&amp;&amp; std::forward&lt;T&gt;(T&amp;&amp; a)</code>

If you declare a function has:

<pre><code> template&lt;class T&gt;
 void foo(ATemplateClass&lt;T&gt; &amp;&amp; a);
</code></pre>

whatever the type deduced for T by the compiler, you'll get a rvalue reference paramater.

The distinction between rvalue references and forwarding references was made clear enough in this example by Scott Meyers: 

<pre><code>Widget&amp;&amp; var1 = someWidget; // here, “&amp;&amp;” means rvalue reference (1)

auto&amp;&amp; var2 = var1; // here, “&amp;&amp;” does not mean rvalue reference (2)

template&lt;typename T&gt;
void f(std::vector&lt;T&gt;&amp;&amp; param); // here, “&amp;&amp;” means rvalue reference (3)

template&lt;typename T&gt;
void f(T&amp;&amp; param); // here, “&amp;&amp;”does not mean rvalue reference (4)
</code></pre>

Essentially the distinction happens when we have a deducible context, hence case (3) explicitly states that we have a <code>vector&lt;...&gt;&amp;&amp;</code> whereas the <code>T</code> in case (4) is to be deduced and (after applying reference collapsing rules) categorized in terms of "value category". 

But what happens with a bit more complex pattern matching? Take the following case for example : 

<pre><code>template &lt;template &lt;class...&gt; class Tuple, class... Ts&gt;
void f(Tuple&lt;Ts...&gt;&amp;&amp; arg)
{

}
</code></pre>

What does <code>&amp;&amp;</code> mean here ?

Is this a forwarding reference?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

Scott Meyer在这个例子中明确了右值引用和转发引用之间的区别：Widget&& var1 = someWidget;     // here, “&&” means rvalue reference (1)auto&& var2 = var1;             // here, “&&” does no...

问这是一个转发参考吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这是一个转发参考吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这是一个转发参考吗？
EN