使用std::forward作为通用引用而不是进一步传递给函数有意义吗？
使用std::forward作为通用引用而不是进一步传递给函数是有意义的。std::forward是C++中的一个模板函数，用于在函数模板中实现完美转发。
完美转发是一种保留参数的值类别（左值或右值）和cv限定符的机制，它允许将参数以原始形式转发给另一个函数。通过使用std::forward，可以实现将参数在函数调用中保持原始值类别和cv限定符的目的。
在C++中，函数参数可以分为左值引用和右值引用两种类型。当传递一个左值给一个函数时，通常会调用拷贝构造函数来复制左值，而传递一个右值时，则会调用移动构造函数来获取右值的内容。然而，如果直接将传入的参数传递给另一个函数时，参数的值类别将会丢失，传递给下一个函数的参数都被视为左值。
通过使用std::forward，可以在函数模板中保留传递参数的原始值类别和cv限定符，使得参数在转发过程中仍然可以被正确地识别为左值或右值。这样，可以避免不必要的拷贝和移动操作，提高代码的性能和效率。
使用std::forward的场景包括但不限于以下情况：
- 在模板函数中需要将参数完美转发给其他函数，以保留参数的值类别和cv限定符。
- 在实现某些通用算法或容器时，需要将传入的参数按原始值类别转发给其他函数进行处理。
在腾讯云的云计算服务中，推荐的产品包括但不限于：
- 云服务器CVM（https://cloud.tencent.com/product/cvm）：提供高性能、可扩展的云服务器实例，适用于各种计算场景。
- 云函数SCF（https://cloud.tencent.com/product/scf）：提供事件驱动的无服务器计算服务，能够按需弹性地运行代码。
- 容器服务TKE（https://cloud.tencent.com/product/tke）：提供全托管的容器集群服务，支持应用的快速部署和管理。
这些产品能够满足用户在云计算领域的需求，提供稳定可靠的计算资源和开发环境。通过使用这些产品，用户可以更便捷地进行开发、部署和管理云计算应用。
相关·内容
4回答
据我所知，在C++11中，应该始终在std::forward中使用通用引用，但我不确定如果不使用std::forward，会出现什么样的问题。
template <T>
void f(T&& x);
{
// What if x is used without std::forward<T>(x) ?
}
你能提供一些例子说明在这种情况下可能出现的问题吗？
浏览 5提问于2014-04-25得票数 10
回答已采纳
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
2回答
通用引用和本地类
、、、、
在下面的代码中，我有一个接受“通用引用”(F&&)的函数。该函数还有一个内部类，它在构造函数中接受F&&的一个对象。在这一点上，F&&仍然是一个普遍的参考吗？也就是说，F是否仍然被认为是一种推导型？
换句话说，我应该在构造函数初始化列表中使用std::forward<F>还是std::move？
#include "tbb/task.h"
#include <iostream>
#include <future>
template<class F>
auto Async(F&
浏览 8提问于2014-09-18得票数 3
回答已采纳
试图理解使用std::forward和auto&&变量是否是传递这些变量以允许移动的正确方法。
假设有一个函数：
void moveWidget(Widget&& w);
以及调用方-引用rvalue和lvalue的两个变量：
Widget w;
auto&& uniRefLV = w; // lvalue initialiser,
// uniRefLV's type is Widget&
auto&& uniRefRV =
浏览 1提问于2013-07-02得票数 9
回答已采纳
在查看std::reference_wrapper 的实现时
构造器和运算符对我来说是显而易见的，但我不明白这部分
template< class... ArgTypes >
typename std::result_of<T&(ArgTypes&&...)>::type
operator() ( ArgTypes&&... args ) const {
return std::invoke(get(), std::forward<ArgTypes>(args)...);
}
谁能帮我简化一下..。将不胜感激
浏览 5提问于2016-06-01得票数 3
回答已采纳
1回答
我有一个带有非默认构造函数的类Object，还有一个包含Object数组的类ManyObjects，这个数组应该由用户使用构造函数的参数初始化。
然后有一个类ManyObjectsWrapper，它继承自ManyObjects，还需要一个数组来初始化ManyObjects。
这是我目前使用的代码。
码
#include <iostream>
#define PRINTFN() std::cout << __PRETTY_FUNCTION__ << std::endl
class Object {
public:
Object(int numb
浏览 0提问于2018-07-19得票数 2
2回答
转发返回值。性病：：需要向前吗？
、、、、
我正在编写库，它封装了其他库中的许多功能和方法。为了避免返回值的处理，我采用了这样的std::forward：
template<class T>
T&& wrapper(T&& t) {
f(t); // t passed as lvalue
return std::forward<T>(t);
}
f返回void并接受T&& (或值重载)。包装器总是返回包装器的参数，对于返回的值，应该保持参数的有效性。我真的需要在return中使用return吗？RVO会让它变得多余吗？事实上，它是一个参考(R或L
浏览 5提问于2012-10-18得票数 37
回答已采纳
我已经了解了std::move是如何工作的，并且只为实践实现了自己的版本。现在我正在尝试理解std::forward是如何工作的：
到目前为止，我已经实现了这一点：
#include <iostream>
template <typename T>
T&& forward_(T&& x)
{
return static_cast<T&&>(x);
}
/*template <typename T>
T&& forward_(T& x)
{
return
浏览 0提问于2020-12-01得票数 7
回答已采纳
2回答
我有以下代码：
#include <iostream>
#include <string>
using std::cout;
using std::endl;
void bar(const std::string& str)
{
cout << "const str - " << str << endl;
}
void bar(std::string&& str)
{
cout << "str - " << str <<
浏览 6提问于2015-09-21得票数 14
回答已采纳
我正在尝试学习一些基本的C++ 11，使用Scott在youtube上的演讲，叫做“一个有效的C++11/14采样器”。
使用他的std::forward示例代码(在讲座中为19分钟)，我编写了以下代码来理解std::forward的效果
#include "stdafx.h"
#include <string>
#include <utility>
class A
{
public:
void Foo(std::string&& s)
{
std::string s2 = std::forward&l
浏览 4提问于2016-07-23得票数 0
回答已采纳
2回答
考虑一下这段代码，它使用了一个常见的成语，即让一个函数模板构造一个类模板的实例，这个实例专门针对一个推导的类型，例如，在std::make_unique和std::make_tuple中可以看到：
template <typename T>
struct foo
{
std::decay_t<T> v_;
foo(T&& v) : v_(std::forward<T>(v)) {}
};
template <typename U>
foo<U> make_foo(U&& v)
{
浏览 3提问于2014-06-30得票数 13
回答已采纳
2回答
我很难找到如何在lambdas中使用std::thread()。即，通过具有可变参数，lambda通过转发接收参数。例如：
template<typename... T>
auto foo(T&&... t){
[](T&&... t){}(std::forward<T>(t)...); // (1)
return std::thread( // (2)
[](T&&... t){},
std::forward<T>(t)...
);
}
auto
浏览 0提问于2018-11-14得票数 4
回答已采纳
1回答
我有下面的代码。
template <typename... Types>
void print_tuple(const std::tuple<Types&&...>& value)
{
std::cout << std::get<0>(value) << "," << std::get<1>(value) << std::endl;
}
print_tuple(std::forward_as_tuple("test",1));
哪个编
浏览 2提问于2015-03-21得票数 7
回答已采纳
1回答
带类模板参数演绎的完美转发
、、、、
我想了解演绎指南如何与通用引用和std::forward一起工作，特别是创建完美的转发包装。下面的代码提供了在两种情况下对函子包装器进行实验的代码:一种是隐式演绎指南，另一种是显式演绎指南。
我在评论中加入了大量的&&和std::forward，因为我不知道在哪里需要它们来实现完美的转发。我想知道把它们放在哪里，哪里不需要它们。
// Case with not conversion constructor
template <class F>
struct functor1
{
explicit constexpr functor1(F/*&&am
浏览 0提问于2017-12-27得票数 9
回答已采纳
在对Rvalue引用的简要介绍中，提出了完美转发作为将rvalue 5转发给具有非const引用参数的构造函数的理想解决方案。
但是：
#include <memory>
#include <iostream>
#include <utility>
template <class T, class A1>
std::shared_ptr<T> factory(A1&& a1) {
return std::shared_ptr<T>(new T(std::forward<A1>(a1)))
浏览 7提问于2011-12-02得票数 7
我有这样的代码：(live：)
struct big_class
{
std::string s1;
std::string s2;
std::string s3;
std::string s4;
std::string s5;
std::string s6;
std::string s7;
};
void func(const big_class &bc)
{
std::cout << bc.s1 << bc.s2 << bc.s3 << bc.s4 << b
浏览 0提问于2021-06-16得票数 1
回答已采纳
2回答
正如我所理解的，作为参数传递给函数的rvalue变成lvalue，std::forward如果参数作为rvalue传递，则返回rvalue，如果作为lvalue传递，则返回lvalue。这是我的班级：
#include <string>
#include <iostream>
struct MyClass
{
MyClass()
{
std::cout << "default";
}
MyClass(const MyClass& copy)
{
std::co
浏览 0提问于2019-02-21得票数 0
回答已采纳
我总是读到std::forward只与模板参数一起使用。然而，我在问自己为什么。请参见以下示例：
void ImageView::setImage(const Image& image){
_image = image;
}
void ImageView::setImage(Image&& image){
_image = std::move(image);
}
这是两个基本相同的函数；一个接受l值引用，另一个接受r值引用。现在，我认为既然std::forward应该返回一个l值引用，如果参数是l值引用，则返回一个r值引用，如果参数是1，则此代码可以简
浏览 4提问于2015-03-03得票数 76
回答已采纳
2回答
正确使用通用引用
、、、、
在c++11之前，我经常编写这样的代码：
// Small functions
void doThingsWithA(const A& a)
{
// do stuff
}
void doThingsWithB(const B& b)
{
// do stuff
}
void doThingsWithC(const C& c)
{
// do stuff
}
// Big function
void doThingsWithABC(const A& a, const B& b, const C& c)
{
/
浏览 2提问于2014-06-19得票数 7
回答已采纳
我有以下模板类(简化为只包含相关部分)，它使用一个名为Push的方法( C++ 11编写)：
template<class T, int Capacity>
class CircularStack
{
private:
std::array<std::unique_ptr<T>, Capacity> _stack;
public:
void Push(std::unique_ptr<T>&& value)
{
//some code omitted that updates an _index m
浏览 3提问于2015-12-15得票数 7
回答已采纳
3回答
当不需要std::forward时，是什么情况？它用于包装内部函数参数，它是模板-rvalue(也就是说，它可以是lvalue或命名为-rvalue)。如：
template<class T>
void outer(T&& t) {
inner(std::forward<T>(t));
}
我猜有一种情况是，内部函数参数是通过值传递的。还有其他的案子吗？当我写std::begin(std::forward<Ct>(ct))时，我有一个问题，Ct是模板-rvalue-ref。
编辑关于可能重复的
如果我没记错的话，这是第三次尝试结束
浏览 5提问于2012-08-21得票数 7
回答已采纳
3回答
我想通过r-或l- value (const)引用将一个(某些具体类型的，比如int)参数传递给成员函数。我的解决方案是：
#include <type_traits>
#include <utility>
struct F
{
using desired_parameter_type = int;
template< typename X, typename = typename std::enable_if< std::is_same< typename std::decay< X >::type, desired_
浏览 5提问于2013-05-05得票数 6
2回答
寻求对性病的澄清：：
、、、
提及
对于所有重载，返回类型已指定为T&& (忽略constexpr)。
但在附于以下示例的说明中：
template<class T>
void wrapper(T&& arg)
{
// arg is always lvalue
foo(std::forward<T>(arg)); // Forward as lvalue or as rvalue, depending on T
}
如果调用wrapper()传递rvalue std::string，则T被推导为std::string (不是std::strin
浏览 1提问于2018-03-11得票数 1
下面是一个拥有作为私有成员的队列和addTask()方法的类，当我编译这个类时，我发现std：：forward有错误：
#include <iostream>
#include <unistd.h>
#include <functional>
#include <vector>
#include <thread>
#include <condition_variable>
#include <queue>
#include <future>
#include <memory>
#inc
浏览 0提问于2020-11-02得票数 1
给定“C++编程语言第4版”中的下列函数模板：
template <typename TT, typename A>
unique_ptr<TT> make_unique(int i, A && a)
{
return unique_ptr<TT>{new TT{ i, std::forward<A>(a) }};
}
我很难理解这到底是怎么回事，
A绝对是一个rvalue，因此make_unique函数似乎在堆上分配其内容，并将该地址保存在unique_ptr中，因此我们不必担心删除它。但是，标准库转发功能是做什么
浏览 7提问于2013-08-22得票数 1
回答已采纳
当我将函数参数用作std::forward的参数时，它们应该是std::forward_as_tuple参数吗？
template<class ... List>
void fn(List&& ... list){
// do I need this forward?
call_fn( forward_as_tuple( forward<List>(list)... ) );
}
我知道它们将作为rvalue引用存储，但是还有什么需要考虑的吗？
浏览 6提问于2014-08-21得票数 14
回答已采纳
例如 for std::forward，
// forward example
#include <utility> // std::forward
#include <iostream> // std::cout
// function with lvalue and rvalue reference overloads:
void overloaded (const int& x) {std::cout << "[lvalue]";}
void overloaded (int&& x) {std
浏览 3提问于2016-02-12得票数 0
回答已采纳
1回答
在此之前，我已经从获得了基本代码，所以这里为他们的工作做好了准备。基本思想是有一个工人池，您可以向其提交任意的函数。
int main(){
WorkerQueue q;
auto job = [](){std::cout << "yay\n";};
q.submit(job)
q.wait_for_completion();
return 0;
}
该实现不能处理job的输入参数。因此，我想扩展它，使其工作如下：
int
main()
{
auto job2 = [](int yay) {
std::cout
浏览 0提问于2018-03-22得票数 0
回答已采纳
5回答
#include <iostream>
#include <vector>
#include <type_traits>
#include <utility>
using namespace std;
template <typename Func, typename... Args>
void proxy(Func f, Args&&... args) {
f(std::forward<Args>(args)...);
}
void real_func(vector<int> v
浏览 0提问于2018-06-22得票数 1
回答已采纳
1回答
我正在学习如何用C++编写通用代码，我决定编写一个哈希表。它的键需要是基元类型，值可以是任何类型。哈希函数需要由用户提供。函数的类型是强加给用户的。
我正在寻找关于代码效率和参数转发是否按预期工作的技巧(完美转发)。同样在get方法中，返回值类型指针比返回std：：可选更好吗？
它只包含嵌入和获取方法，保持整洁的东西。
#pragma once
#include <list>
#include <optional>
#include <type_traits>
template< class KeyType > using hashFuncti
浏览 0提问于2022-01-28得票数 5
回答已采纳
2回答
可变模板参数生成
、、
假设我有一个函数foo()，它利用了c++多变的模板特性。现在，这些实现之间有什么区别：
template <typename... Args>
void foo(Args... args) {
whatever(args...);
}
template<typename... Args>
void foo(Args&... args) {
whatever(args...);
}
template<typename... Args>
void foo(Args... args) {
whatever(&args...);
}
temp
浏览 7提问于2016-06-10得票数 1
回答已采纳
2回答
因此，我试图构建一个“清除器”函数，在将格式化参数转发到printf之前过滤它们。
template<typename A>
_CR_INLINE decltype(auto) sanitize_forward(A&& arg) {
return std::forward<A>(arg);
}
template<>
_CR_INLINE decltype(auto) sanitize_forward<std::string>(std::string&& arg) {
return std::for
浏览 2提问于2017-12-29得票数 3
2回答
在此代码中复制a和b是不可避免的吗？我认为保持引用是不可能的，因为一些传递的值可能是rvalue。看看我还能用些什么..。
template<typename S, typename T>
static bool TEST_EQ(S&& expected, T&& received, std::string const & error_msg)
{
auto a = forward<S>(expected);
auto b = forward<T>(received);
bool test =
浏览 1提问于2018-05-06得票数 2
回答已采纳
当我传递左值引用时，我有一个关于用编写的代码的问题，如果我不用std::decay_t删除引用，我会得到一个错误。
这是错误消息
'error：'operator()‘不是main()：：<lambda(auto:11，int)>&的成员
我不明白为什么有必要排除左值引用。
我想知道这个错误意味着什么。
#include <iostream>
#include <utility>
template <typename F>
class
FixPoint : private F
{
public:
explicit
浏览 6提问于2022-03-09得票数 0
回答已采纳
2回答
在下面的代码中 #include <utility>
template <int i = 0, class F, typename... ArgsType>
void g(F&& f, ArgsType&&... args)
{
if constexpr (i < 1) {
f(std::forward<ArgsType>(args)...);
g<1>(std::forward<F>(f), std::forward<ArgsType>(args)...);
浏览 33提问于2021-08-25得票数 0
回答已采纳
2回答
是否可以存储一个行为类似于以下函数的函数：
void target(int foo, size_t bar) {}
void target(std::string foo, int bar) {}
template<T...>
void forwarding_func(T&&... args)
{
target(std::forward<T>(args)...);
}
auto forwarding_callable = ?
如何为具有与forwarding_func相同行为的类型T构建可调用对象。我必须存储它供以后使用，所以我确实需要一个
浏览 8提问于2017-10-07得票数 1
回答已采纳
1回答
有什么好的方法可以在模板类中实现功能的完美转发吗？具体来说，在代码中
#include <iostream>
// Forward declare a Bar
struct Bar;
// Two different functions that vary based on the kind of argument
void printme(Bar const & bar) {
std::cout << "printme: constant reference bar" << std::endl;
}
void print
浏览 2提问于2015-04-14得票数 4
回答已采纳
我一直看到std::forward被使用如下，在模板函数中使用
template<class T>
void foo(T&& arg): bar(std::forward<T>(arg)){}
假设我想这么做。
class A
{
private:
std::function<void()> bar;
public:
template<class T>
A(T&& arg):
bar(std::forward<T>(arg))
{}
};
因为bar已经定义了它的类型。我也可以将
浏览 1提问于2016-06-02得票数 2
回答已采纳
2回答
我可能在这里缺少一些基本的东西，但是为什么我不从std:forward bellow得到一个值呢？
#include <iostream>
#include <utility>
template <typename T>
void f(const T& lhs) {
std::cout << "lvalue" << "\n";
}
template <typename T>
void f(const T&& rhs) { // const, so as not
浏览 11提问于2022-02-19得票数 3
使用各种模板参数和一个简单的模板参数，我体验了is_base_of从绑定函子实例化时的一些奇怪行为。
以下是代码：
template <class T, class Index>
class Base{};
template<typename T>
struct Checker {
typedef int result_type;
// Returns 1 if a given T type is descendant of Base<T,First>
template<typename First, typename ..
浏览 4提问于2011-08-19得票数 2
回答已采纳
1回答
当我在上读到std::forward函数是如何工作的时候，我遇到了一个我不太理解的问题。假设我们有一个如下的函数foo：
template<typename T>
void foo(T&& fooParam)
{
...
someFunc(std::forward<T>(fooParam));
}
在这本书中，斯科特解释说，std::forward<T>可以通过以下方式实现：
template<typename T>
T&& forward(typename remove_reference<
浏览 2提问于2016-12-19得票数 2
2回答
如何存储通用引用
、、、、
我需要在一个类中存储通用引用(我确信被引用的值会比这个类更持久)。有没有规范的方法来做到这一点呢？
这是我想出的一个最小的例子。它似乎起作用了，但我不确定我是否做对了。
template <typename F, typename X>
struct binder
{
template <typename G, typename Y>
binder(G&& g, Y&& y) : f(std::forward<G>(g)), x(std::forward<Y>(y)) {}
void op
浏览 2提问于2013-02-08得票数 8
回答已采纳
1回答
我使用以下代码将成员函数绑定到类的实例：
class Foo {
public:
int i;
void test() {
std::cout << i << std::endl;
}
};
int main() {
Foo f;
f.i = 100;
auto func = std::bind(&Foo::test, std::forward<Foo>(f));
f.i = 1000;
func();
}
但是std::bind语句并不通过引用绑定到f。调用func会
浏览 0提问于2014-10-04得票数 18
回答已采纳
2回答
获取lambda表达式的返回类型
、、、、
我正在开发一个C++迭代器，它在迭代器被取消引用时评估一个lambda表达式。
因此，我实现了一个自定义迭代器类，并重载了dereference操作符，在每次取消引用上执行lambda表达式，这样我就可以将我需要的表达式放在lambda函数中。
一切正常，但它不是类型-泛型，因为在下面代码的第9行，我假设lambda表达式将返回一个double。如何获得返回类型的Lambda？我试过std::result_of<Lambda>，但没成功。
下面是我写的代码：
#include <iostream>
#include <vector>
#include <
浏览 0提问于2019-01-22得票数 0
回答已采纳
当与std::piecewise_construct一起使用时，我对std::map感到有点困惑。示例：
std::map<std::string, std::string> m;
// uses pair's piecewise constructor
m.emplace(std::piecewise_construct,
std::forward_as_tuple("c"),
std::forward_as_tuple(10, 'c'));
我不知道emplace()如何知道在使用piecewis
浏览 4提问于2014-12-01得票数 8
回答已采纳
在VS2010中std::forward是这样定义的：
template<class _Ty> inline
_Ty&& forward(typename identity<_Ty>::type& _Arg)
{ // forward _Arg, given explicitly specified type parameter
return ((_Ty&&)_Arg);
}
identity似乎仅用于禁用模板参数推导。在这种情况下，故意禁用它的意义是什么？
浏览 2提问于2011-10-16得票数 29
回答已采纳
当使用通用引用时，std::move是否需要与std：：前进相结合？例如，以下两段代码中哪一段是正确的？
void bar(auto && x) {
auto y(std::move(std::forward<decltype(x)>(x)));
}
或
void bar(auto && x) {
auto y(std::move(x));
}
基本上，我想把x的内存移到y中，我不在乎它是l值引用还是r值引用。当然，我不希望const值出现在这里。
浏览 1提问于2015-01-07得票数 1
回答已采纳
2回答
我正在做一些实验，试图了解转发是如何工作的，我到了我不明白的情况。
当我用clang3.8-O3编译时
class Foo {
Foo(const std::string& s) : str(s) {}
std::string str;
};
和
class Foo {
Foo(std::string&& s) : str(std::forward<std::string&>(s)) {}
std::string str;
};
在第一种情况下，用Foo foo("this is a test")构造Foo几乎要快2倍
浏览 2提问于2016-01-01得票数 3
回答已采纳
3回答
考虑：
void g(int&);
void g(int&&);
template<class T>
void f(T&& x)
{
g(std::forward<T>(x));
}
int main()
{
f(10);
}
既然id表达式x是一个lvalue，而且std::forward重载了lvalue和rvalue，那么为什么调用不绑定到接受lvalue的std::forward重载呢？
template<class T>
constexpr T&& forward(std:
浏览 7提问于2015-03-19得票数 14
回答已采纳
1回答
我有以下代码：
#include <iostream>
#include <typeinfo>
template <typename T>
struct A : T {
template <typename ...Args>
A(Args&&... params) : T(std::forward<Args>(params)...), x(0) {
std::cout << "Member 'x' was default constructed\n&
浏览 2提问于2014-09-23得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
