为什么rvalue int向量的元素的decltype(auto)的类型推导是int&？
rvalue int向量的元素的decltype(auto)的类型推导是int&的原因是因为decltype(auto)会根据表达式的类型进行类型推导，而rvalue int向量的元素是右值引用，它的类型推导会保留其引用性质。在C++中，rvalue引用是一种特殊的引用类型，它可以绑定到临时对象或将要销毁的对象，但不能绑定到左值。当使用decltype(auto)对rvalue int向量的元素进行类型推导时，由于元素是右值引用，推导结果会保留其引用性质，因此推导出的类型是int&。
rvalue int向量的元素的类型推导为int&的优势是可以直接操作原始数据，避免了拷贝构造的开销，提高了程序的性能。此外，通过引用可以实现对元素的修改，方便进行数据的更新和处理。
rvalue int向量的元素的类型推导为int&的应用场景包括但不限于：
- 在算法中需要对元素进行修改或操作时，可以使用rvalue引用来避免不必要的拷贝构造，提高效率。
- 在函数返回值中，可以使用rvalue引用来避免拷贝构造，减少内存开销。
- 在多线程编程中，可以使用rvalue引用来避免数据竞争和锁的开销，提高并发性能。
腾讯云相关产品和产品介绍链接地址：
暂无相关产品和链接地址。
相关·内容
2回答
int&& i = 42;和int i = 42;有什么区别吗？
关于std::forward，我在网上读到“如果arg是一个lvalue引用，函数返回arg而不修改它的类型”。然而，以下代码：
void f(int& k)
{
std::cout << "f(int&) " << k << std::endl;
}
void f(int&& k)
{
std::cout << "f(int&&) " <<
浏览 1提问于2016-07-22得票数 1
回答已采纳
1回答
捕获不同的模板类型？
、、、
例如，我有如下代码
template<class... Ts>
void f(Ts... args)
{
}
传递下列参数时
int j = 5;
int& i = j;
f(i);
和
void g(int& i)
{
f(i);
}
捕获的类型不是int&在上述两种情况下都是int。如何让它捕获与我相同类型的int&？谢谢。
浏览 1提问于2014-05-22得票数 1
回答已采纳
1回答
从C++ lambda返回类型
、、、、
我有兴趣了解尾随auto&&返回类型的确切含义，特别是区别于这里不工作的decltype(auto)，以及未指定的返回类型，后者也不起作用。
在下面的代码中，fn返回参数的x_字段。当参数是lvalue时，x_返回为lvalue，等等。
在fn_bad[123]的示例中，它似乎返回int，即使提供了lvalue参数。我明白为什么-> auto会导致这种情况，但我希望-> decltype(auto)返回int&。为什么只有-> auto&&才能工作？
#include <utility>
struct Foo { int
浏览 2提问于2020-05-12得票数 3
回答已采纳
#for example:
#1:
template <typename T>
void func(T &) {}
int a;
const int b;
func(a); // T -> int
func(b); // T -> const int
func(5); // wrong. 5 is a right value
#2:
template <typename T>
void func(const T &) {}
int a;
const int b;
func(a
浏览 0提问于2019-03-18得票数 3
回答已采纳
1回答
自动返回类型不推演引用
、、、
我有以下代码：
#include <iostream>
struct C {
int a;
int& get() { return a; }
};
struct D {
int a;
int get() { return a; }
};
template <typename T>
auto foo(T o) { // no sample code is complete without a foo
return o.get();
}
int main()
{
C c;
D d;
c.a = 2;
浏览 0提问于2019-06-03得票数 12
回答已采纳
const int n = 0;
auto& n1 = const_cast<int&>(n);
auto n2 = const_cast<int&>(n);
C++11标准通过auto n2 = const_cast<int&>(n);保证n2 is int&吗？
我必须使用auto& n1 = const_cast<int&>(n);而不是auto n2 = const_cast<int&>(n);吗
按照C++11标准，这两种方式完全等价吗？
浏览 3提问于2016-12-06得票数 4
回答已采纳
2回答
考虑以下几点：
auto list = std::make_tuple(1, 2, 3, 4);
/// Work like a charm
template <class T>
auto test1(T &&brush) -> decltype(std::get<0>( std::forward<T>(brush) )) {
return std::get<0>( std::forward<T>(brush) );
}
/// And now - C++14 feature
/// fail to
浏览 3提问于2014-06-10得票数 3
回答已采纳
1回答
#include <type_traits>
#include <utility>
int main()
{
auto f1 = [](auto&& e) -> auto
{
return e;
};
auto f2 = [](auto&& e) -> auto&
{
return e;
};
auto f3 = [](auto&& e) -> auto&&
{
r
浏览 0提问于2018-12-11得票数 2
回答已采纳
2回答
为什么auto&不是参考价值？
Widget&& var1 = Widget(); // rvalue reference
auto&& var2 = var1; //var2 not rvalue reference
下面是rvalue引用示例
void f(Widget&& param); // rvalue reference
Widget&& var1 = Widget(); // rvalue reference
为什么var2不是rvalue引用，而f和var2是rvalue引用？
浏览 1提问于2016-01-20得票数 3
回答已采纳
1回答
我正在尝试理解C ++中的Lvalue和Rvalue。
所以我用它们作为传递给函数的参数。在第一个例子中，我有两个函数，第一个函数引用一个const，在本例中，由于"const“(请参阅)，我可以将Lvalue和Rvalue传递给第一个函数，我不会有任何问题。相反，在第二个函数中，我必须传递一个Rvlaue，否则我会得到错误描述。
void f1(const int& n){cout<<"[Lvalue]"<<endl;}
void f2(int&& n){cout<<"[Rvalue]"<
浏览 2提问于2018-12-11得票数 1
回答已采纳
2回答
template<typename T>
void F(T&& x) {}
如果我们用整数类型的参数来调用它&一切都是明确的--引用就会发生崩溃，而且我们仍然有lvalue-引用。但是，如果我们用int参数来调用它，会发生什么。我的想法是:我们已经推导了T=int类型，用rvalue-引用来修饰它，所以F采用整&参数，用int类型调用它会导致错误。但在实数F中，这类论点被认为是一种参考。参考价值从何而来？编译器应用了什么规则来获得int& from int？
浏览 4提问于2017-12-09得票数 0
回答已采纳
考虑以下代码：
#include <iostream>
#include <type_traits>
#include <functional>
#include <utility>
template <class F>
constexpr decltype(auto) curry(F&& f)
{
if constexpr (std::is_invocable_v<decltype(f)>)
{
return std::invoke(f);
}
else
浏览 11提问于2022-03-30得票数 1
回答已采纳
5回答
auto与decltype的关系
、、、、
是
auto x = initializer;
等同于
decltype(initializer) x = initializer;
或
decltype((initializer)) x = initializer;
或者两者都不是？
浏览 0提问于2011-07-29得票数 35
回答已采纳
我发现了这个类型特征，它可以用来检查某个类型的T是否支持operator<<。
template<class Class>
struct has_ostream_operator_impl {
template<class V>
static auto test(V*) -> decltype(std::declval<std::ostream>() << std::declval<V>());
template<typename>
static auto test(...
浏览 14提问于2022-08-17得票数 1
回答已采纳
我理解i是一个lvalue，而5实际上是一个rvalue (即5是未命名的)。我知道如何使用template <typename T> void fun(T&& x);，以及何时使用它，但我仍然无法理解为什么fun(i)被推断为fun<int&>而不是fun<int>，因为i是int的类型，而不是引用？
我知道有很多关于rvalue\lvalue和正向引用的问题，但是我的问题完全不同。我浏览过许多相关的答案，没有人详细解释过。。
下面是相关的代码片段：
template <typename T>
void fun(T&am
浏览 1提问于2020-06-13得票数 0
2回答
转发引用(也称为通用引用)的整个前提是，该函数：
template<typename T>
void f(T&&) { }
可能导致模板参数为int&或int，这取决于您是否以int a{}; f(a)或f(5)为例调用它。但我认为这已经走得太远了。因为当我有一个函数的时候
template<typename T>
auto g(T) -> void {}
然后，它总是将模板参数解析为int，而不管我如何调用它。尽管auto h(int&) -> void {}是完全合法的。
那么，哪些规则允许f的模板参数成为引用，而不是g的
浏览 5提问于2021-12-22得票数 2
回答已采纳
我有以下C++14 lambda https://godbolt.org/z/aexxTY #include <boost/optional.hpp>
int main(){
auto foo = [](auto && t)
{
using T = decltype(t);
return boost::optional<T>(std::forward<T>(t));
};
// This is fine because i is lvalue
auto i =
浏览 12提问于2021-02-09得票数 2
回答已采纳
我有一个名为TypeHolder的结构，它基本上是一个T类型的薄包装器：
template <typename T>
struct TypeHolder {};
现在，我想创建一个函数，它接受任何类型的对象，如果对象是TypeHolder (T是TypeHolder的类型)，则将该对象转换为T。如果不是，函数应该只保留对象的原始类型。
我试图像这样定义这样的函数：
template <typename T>
auto castToObjIfTypeHolder(T obj, char) -> T; // This overload is called if T i
浏览 1提问于2021-04-09得票数 0
回答已采纳
我在玩时注意到了std::result_of的这种行为：
struct Foo {
int operator()(const int&) const { ... }
char operator()(int&&) const { ... }
};
result_of_t<Foo(const int&)> a; // int
result_of_t<Foo(int&&)> b; // char
result_of_t<Foo(int)> c; // char -- w
浏览 5提问于2016-06-15得票数 1
回答已采纳
1回答
我想了解int &如何与double一起与declval一起分配给declval？T被推断为int &以外的其他东西吗？
#include <iostream>
#include <type_traits>
#include <utility>
template <typename T, typename U, typename = void>
struct assignment : std::false_type{};
template <typename T, typename U>
struct assign
浏览 3提问于2022-05-15得票数 0
回答已采纳
2回答
从我个人的经验和对像这样的问题的解答中，我可以找到很多有价值的decltype(auto)用例作为函数返回类型占位符。
但是，我很难想到decltype(auto)变量的任何有效用例(即有用的、现实的、有价值的)。想到的唯一可能是存储返回decltype(auto)的函数的结果，以便以后的传播，但是auto&&也可以在那里使用，而且会更简单。
我甚至在我的所有项目和实验中搜索过，decltype(auto)的391次出现都是返回类型占位符。
那么，decltype(auto) 变量有什么实际的用例吗？还是只有作为返回类型占位符使用时才有用？
你如何定义“现实”？
我正
浏览 0提问于2019-08-09得票数 28
回答已采纳
在C++14中，为什么默认情况下具有导出返回类型的lambda函数会从返回类型中删除引用？IIUC，因为具有导出返回类型(没有显式尾随返回类型)的C++14 lambda函数有一个auto返回类型，它删除引用(除其他外)。
为什么要做出这个决定？在我看来，当返回语句返回引用时，移除引用似乎是个难题。
这种行为给我造成了以下令人讨厌的错误：
class Int {
public:
Int(int i) : m_int{i} {}
int m_int;
};
class C {
public:
C(Int obj) : m_obj{obj} {}
const auto
浏览 3提问于2017-01-08得票数 7
回答已采纳
1回答
例如，以范围：：fill算法为例：
签名是：
template< class T, ranges::output_range<const T&> R >
constexpr ranges::borrowed_iterator_t<R> fill( R&& r, const T& value );
举个例子：
#include <algorithm>
#include <vector>
#include <iostream>
int main()
{
std::vector<
浏览 3提问于2022-01-27得票数 4
回答已采纳
1回答
我想知道在基于范围的for循环中，for (auto& i : v)和for (auto&& i : v)有什么区别，如下代码所示：
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v = {0, 1, 2, 3, 4, 5};
std::cout << "Initial values: ";
for (auto i : v) // Prints the initial values
浏览 2提问于2015-03-28得票数 26
回答已采纳
2回答
参考模板参数的力推导
、、、
以下代码不编译，因为编译器推断模板参数为int，而模板参数必须是int &。在Coliru 上看。
#include <iostream>
#include <utility>
template <class F, class... ArgsType>
void do_something(F f, ArgsType... args)
{
f(std::forward<ArgsType>(args)...);
}
int main()
{
int s = 2;
int i = 1;
auto add =
浏览 0提问于2019-06-24得票数 2
回答已采纳
std::forward的标准签名是： template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&) noexcept;
template<typename T>
constexpr T&& forward(std::remove_reference_t<T>&&) noexcept; 因为参数类型不是直接为T的，所以我们应该在使用std::forward时指定模板参数 template<typenam
浏览 29提问于2020-04-19得票数 3
假设我想要一个普通的高阶函数。最常见的方法是：
A.通用羔羊a
auto F1 = [](auto f) { /*...*/ }
B.功能模板
template<class F> auto F2(F&& f) { /*...*/ }
我的问题是如何在高阶函数中使用 f。虽然只有一种方法可以防止A：
std::forward<decltype(f)>(f)(...);
案例B至少有两种方法：
std::forward<decltype(f)>(f)(...);
std::forward<F>(f)(...);
这些方法是否等同
浏览 4提问于2015-10-18得票数 1
回答已采纳
2回答
假设这段代码如下所示，那么问题是为什么"c“的cv限定符(const)不被保留，其行为与"v”不同？
int main(int argc, char **argv) {
int x{};
int y{};
const auto [v] = std::tuple<int>(x);
const auto [c] = std::tuple<int&&>(std::move(y));
decltype(v) vv = 10; // vv -> const int;
decltype(c) cc = 100; //
浏览 2提问于2020-07-25得票数 2
回答已采纳
5回答
我正在阅读，在幻灯片288中给出了std::forward的实现
template<typename T> // For lvalues (T is T&),
T&& std::forward(T&& param) // take/return lvalue refs.
{ // For rvalues (T is T),
return static_cast<T&&>(param); // t
浏览 11提问于2014-12-16得票数 54
回答已采纳
5回答
C++中(x)的类型
、、、
给予：
decltype(auto) f1()
{
int x = 0;
return x; // decltype(x) is int, so f1 returns int
}
decltype(auto) f2()
{
int x = 0;
return (x); // decltype((x)) is int&, so f2 returns int&
}
(取自Scott的“有效的现代C++”)
现在，如果我找到了正确的段落，节7.1.5.2 C++标准的简单类型说明符dcl.type.simple说：
如果e是id表达式或类成员访问
浏览 5提问于2015-11-02得票数 21
2回答
以下代码
#include <functional>
#include <tuple>
#include <iostream>
struct Point
{
int x;
int y;
};
decltype(auto) memrefs(Point &p)
{
return std::make_tuple(std::ref(p.x), std::ref(p.y));
}
int main()
{
Point p;
auto& [x, y] = memrefs(p);
x = 1;
浏览 7提问于2021-12-20得票数 0
回答已采纳
1回答
我很难从兰博达那里返回一个推荐信。此代码适用于：
std::function<int*(int*)> funct;
funct = [](int *i){
++*i;
return i;
};
int j = 0;
LOG<<*funct(&j)<<j;
产出:1 1
但不是这个：
std::function<int&(int&)> funct;
funct = [](int &i){
++i;
return i;
};
int j = 0;
LOG<<funct
浏览 1提问于2017-09-26得票数 8
回答已采纳
2回答
让我们考虑一下下面的代码片段
void Test()
{
int x = 0;
int& rx = x;
int* px = &x;
auto apx = px; // deduced type is int*
auto arx = rx; // deduced type is int
}
人们可以从指针类型中进行类比，期望推导出的arx类型是int&，但实际上它是int。
标准中管理这一点的规则是什么？背后的原因是什么？在这样的情况下，有时我会被它抓住：
const BigClass& GetBigClass();
浏览 1提问于2012-08-09得票数 10
回答已采纳
1回答
为什么引用折叠规则只适用于模板？
、、、、
#include <iostream>
template <typename T> void f1(T&& r1){
std::cout<<r1;
}
void f2(int&& r2){
std::cout<<r2;
}
int main() {
int&& x = 42;
f1(x); //line 1: No error here. Why?
f2(x);//line2: Error here. why?
}
我想我理解为什么我们在第2行有一个错误
浏览 6提问于2017-10-16得票数 3
回答已采纳
1回答
那两个人有什么区别吗？
struct S;
int& foo(S&);
auto&& bar1(S& s) {
return foo(s);
}
decltype(auto) bar2(S& s) {
return foo(s);
}
为了编译器？在这种情况下，我一直在使用decltype(auto)，但似乎是auto&&起了作用。这是巧合还是两者是相同的？
浏览 1提问于2020-09-10得票数 4
回答已采纳
我是C++的新手，目前正在努力了解模板函数是如何工作的。首先，我想添加两个相同类型的数值，这很容易理解。
template <typename T>
T add(T a, T b){return a+b;}
int main(){
float a_f=2.5;float b_f=1.5;float c_f;
int a_i=2;int b_i=1;int c_i;
c_f = add(a_f, b_f);
c_i = add(a_i, b_i);
return 0;
}
接下来，我想要添加两个具有不同和相等类型的数字。我天真的假设是：
tem
浏览 3提问于2020-02-03得票数 0
回答已采纳
1回答
有没有办法转发一个对(或元组)的元素，同时保持它的引用类型(例如，继续是一个右值)？ 下面的例子演示了我尝试过的方法:转发和移动元素对(第一个和第二个)，移动元素对并使用其元素，以及移动元素对和元素。我希望所有的东西都能工作，但没有一个能做到。 template<class T, class U>
auto pair_forward(std::pair<T, U>&& p)
{
return std::make_pair(std::forward<T>(p.first), std::forward<U>(p.second
浏览 14提问于2019-05-08得票数 0
回答已采纳
在下面的代码中，我使用auto定义了一个与所使用的迭代器兼容的新变量"temp“。我只是好奇，我是否可以做同样的，而不用自动关键字？
换句话说，我不知道容器是什么。那么，如何在不损害代码的通用性的情况下定义temp变量。
作为C++的新手，我一直在用它来回答任何问题。我曾寻找过类似的问题，但我没有找到任何问题。任何帮助都将不胜感激！！
/* InsertionSort.c */
#include<iostream>
#include <typeinfo>
namespace sort {
template <class RandomAccessIte
浏览 5提问于2013-12-08得票数 2
回答已采纳
对一些人来说，这似乎是显而易见的，但我仍然在想:没有办法让编译器在没有实际调用的情况下推断lambda返回类型吗？
你当然可以auto retval = myLambda();，但我想要的是：
T_MY_LAMBDA_RETVAL retval;
...
retval = myLambda();
我为什么要那样？简单：
try {
auto retval = myLambda();
catch (exception e) {
...
}
// retval is undefined but I wonna have it!!! :)
浏览 0提问于2014-05-26得票数 1
回答已采纳
我对结构约束感到很困惑。即使我使用const和by(没有&)结构绑定，如本例所示：
#include <iostream>
#include <tuple>
int main()
{
int x = 0;
std::tuple<int&> p(x);
const auto [a] = p;
a++;
std::cout << x << '\n';
}
它仍然修改x并打印1：
如果我在&之前添加[a]或删除const，请您解释为什么会这样工作，并希望进行更
浏览 4提问于2021-06-26得票数 4
回答已采纳
关于std::forward的用法令我费解。这是我编辑的版本：
#include <iostream>
#include <memory>
#include <utility>
using namespace std;
struct A{
A(int&& n) { cout << "rvalue overload, n=" << n << "\n"; }
A(int& n) { cout << "lvalue overload,
浏览 1提问于2012-04-30得票数 1
回答已采纳
1回答
考虑以下片段：
#include <iostream>
#include <vector>
#include <functional>
int main()
{
std::vector<int>v = {0,1,2,3,4,5,6};
std::function<const int&(int)> f = [&v](int i) { return v[i];};
std::function<const int&(int)> g = [&v](int i) ->
浏览 0提问于2015-04-13得票数 29
我们知道和接受数组类型参数，我们需要使用对数组的引用来声明函数模板：
template<class T, std::size_t N>
std::size_t number_of_elements(T (&ary)[N]) {
return N;
}
但是，为什么我们不需要在类模板中声明对数组的引用参数呢？下面的代码显示了这一点，并在C++11下编译。
template<class T>
struct cls_number_of_elements {};
template<class T, std::size_t R>
struct cls_n
浏览 4提问于2015-11-16得票数 3
回答已采纳
首先，我构造了四个结构，每个结构返回value，l-value引用，const l-value引用，r-value引用。我在包装器(B或C)中使用它们，在这些包装器的方法func()中，我希望保留A的func()的引用和cv限定符。
在c++11中，我使用了尾随返回类型。但是随着c++14中正常返回类型演绎的到来，我猜我可以跳过后面的部分，但只有在使用auto时，返回类型才会像普通的auto一样忽略限定符和引用。
那么，我的问题是，在行为类似于下面的B类的c++14中实现它的最佳方式是什么？有时编写尾部(通常是decltype(返回表达式))会让人沮丧，因为它是微不足道的。
struct A1
浏览 1提问于2013-05-30得票数 5
回答已采纳
2回答
通用引用l-值不复制对象
、、、、
为什么这些断言适用于下面的代码？通用引用应该绑定到l值引用run(T& a)，并从a复制对象b .但是，在run()函数中，这两个对象的地址都是"a“和"b”。用C++11/14/17/2a gcc-9.2和clang++-6.0进行测试。标准的哪一部分说这是有效的？没有发现任何相关的东西。
#include <cassert>
#include <utility>
template <typename T>
void run(T&& a)
{
T b {std::forward<T>(a)};
浏览 3提问于2020-06-20得票数 1
回答已采纳
以下代码无法编译：
#include <iostream>
using namespace std;
int add2(const int& x)
{
return x + 2;
}
template <typename T>
T add2T(T&& x) {
return add2(std::forward<T>(x));
}
int main(int argc, char** argv) {
int x = 0;
cout << "Add 2" <<
浏览 4提问于2017-12-01得票数 5
回答已采纳
2回答
我有一个关于转发推荐信的具体问题。(我想)我理解r值引用和std::move，但是我很难理解转发引用：
#include <iostream>
#include <utility>
template <typename T> class TD; // from "Effective Modern C++"
void consume(const int &i) { std::cout << "lvalue\n"; }
void consume(int &&i) { std::co
浏览 2提问于2021-03-10得票数 4
回答已采纳
给定以下模板结构：
template<typename T>
struct Foo {
Foo(T&&) {}
};
这是编译的，T被推断为int。
auto f = Foo(2);
但这不能编译：
int x = 2;
auto f = Foo(x);
/*
<source>:12:15: error: no viable constructor or deduction guide for deduction of template arguments of 'Foo'
auto f = Foo(x);
浏览 0提问于2020-02-29得票数 9
回答已采纳
我读了的问题，我知道rvalue引用是一个lvalue。
但是，对于此代码，示例1，
int &&fun() {
return 1;
}
int main() {
int &a = fun();
}
当我编译它时：
error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int'
因此，C++编译器告诉我，返回类型的fun是一个rvalue。
rvalue引用是如何变成rvalue的？
浏览 2提问于2018-05-26得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
