是否可以省略` `std::forward`中的模板参数？
在C++中，std::forward是一个模板函数，它用于实现完美转发。完美转发是指将参数原封不动地传递给另一个函数，同时保留其左值或右值属性。std::forward通过根据传递给它的参数的值类别来选择合适的重载来实现这一目的。
由于std::forward是一个模板函数，它的模板参数类型是必需的。这是因为模板参数类型提供了编译器推导正确参数类型的信息，从而使std::forward能够正确选择要调用的重载函数。
因此，不能省略std::forward中的模板参数。必须显式指定参数类型，以确保完美转发的正确性。
腾讯云提供了一系列的云计算产品，其中包括云服务器、云数据库、云存储等。您可以访问腾讯云官方网站（https://cloud.tencent.com/）获取更详细的产品信息和文档。
相关·内容
我有这样一门课： template <typename T>
class Value {
private:
bool fixed;
union {
T value;
std::function<T()> get;
};
public:
Value(const T& value);
template <typename F, typename = std::enable_if_t<std::is_invocable_v<F>>>
浏览 119提问于2020-12-08得票数 0
回答已采纳
我正在编写一个带有迭代器标签的函数来处理不同的迭代器。但是，我想做一个后备，所以使用了一个模板。我本以为模板的优先级会比转换为基类型的优先级低。我错了：
#include <iterator>
#include <iostream>
using namespace std;
void test(std::forward_iterator_tag) {
cout << "forward_iterator_tag" << endl;
}
void test(std::random_access_iterator_tag) {
浏览 0提问于2021-10-24得票数 1
2回答
我在模板参数列表中见过几次class = std::enbale_if<condition, type>::type，我知道std::enable_if<B,T>::type做什么，但不确定class =做什么？我的意思是我知道class type_name = type，但是为什么在class =中没有类型名称？我什么时候能用？
编辑:这个例子来自
template <class T, class U, class = typename enable_if
<is_lvalue_reference<T>::value ? i
浏览 6提问于2016-06-16得票数 4
回答已采纳
1回答
// I can't change this function!
template<typename Function, typename... Args>
void RpcWriteKafka(Function func, Args&&... args) {
func(std::forward<Args>(args)...);
}
// I can change this one if necessary.
template<typename FUNC, typename... Args, typename CALLBACK,
浏览 7提问于2022-05-11得票数 0
回答已采纳
2回答
我正在为std::jthread和一些周围的基础设施编写一个包装器。我无法理解为什么以下内容不能编译：
#include <iostream>
#include <map>
#include <functional>
#include <thread>
// two random functions
void foo(int i) { std::cout << "foo " << i << std::endl; }
void bar(int i) { std::cout << &
浏览 18提问于2022-03-03得票数 1
回答已采纳
3回答
实际上，我遇到了以下问题:我希望能够使用-Wall -Wextra -Werror进行构建，但是，下面的代码会抱怨未使用的参数：
struct foo
{
template <typename... Args>
static void bar()
{ }
template <typename T, typename ... Args>
static void bar(T&& value, Args&& ... args)
{
#ifdef DEBUG
std::co
浏览 0提问于2013-10-23得票数 12
回答已采纳
在C++11中，有像这样的可变模板：
template< class T, class... Args >
unique_ptr<T> make_unique( Args&&... args )
{
return unique_ptr<T>(new T(std::forward<Args>(args)...));
}
这里有一些奇怪的地方:表达式std::forward<Args>(args)...同时使用Args和args，但只使用一个...标记。此外，std::forward是一个非可变模板函数，只接受一个
浏览 1提问于2013-07-15得票数 100
回答已采纳
例如，std::less的比较被定义为模板结构
template< class T = void >
struct less;
而std::compare_three_way被定义为一个普通结构，它的operator()是一个模板函数。(代码来自MSVC)
struct compare_three_way {
template <class _Ty1, class _Ty2>
requires three_way_comparable_with<_Ty1, _Ty2> // TRANSITION, GH-489
constex
浏览 0提问于2020-10-29得票数 3
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
让我们从一个代码开始(请注意，它被缩短了，只显示有问题的部分)。
#include <type_traits>
#include <utility>
#include <list>
#include <forward_list>
#include <functional>
template<typename Container, typename Compare>
class SortedContainer
{
public:
template<typename... Args>
auto
浏览 6提问于2015-01-09得票数 2
回答已采纳
1回答
用MSVC++编译，但在GCC 4.5.1中没有编译：
#include <iostream>
template< typename PT, bool pB >
struct TA
{
PT m;
TA( PT fT ) :
m( fT )
{
std::cout << "TA<" << pB << ">::TA() : " << m << std::endl;
}
PT operator()( PT fT )
{
std
浏览 1提问于2012-01-13得票数 1
回答已采纳
2回答
表达式包含未展开的参数包
、、、
不知何故，我不明白可变模板参数包是如何扩展的。下面的代码有什么问题？
#include <iostream>
template <typename T>
struct print_one
{
static void run(const T& t)
{
std::cout << t << ' ';
}
};
template<typename... Args>
void print_all(Args&&... args)
{
// the nex
浏览 2提问于2012-09-20得票数 14
回答已采纳
1回答
元算子的优先级是多少.？
、、、、
元操作符...的优先级是什么?它的工作是解压缩模板类型参数包？我想它很低，但它有多低？C++标准说：
运算符的优先级不是直接指定的，但可以从语法派生。
有人准备好迎接挑战了吗？当然，...不会出现在C++03运算符优先级表中。
好吧，如果...不是运算符，那么究竟是什么决定了std::forward<Args>(args)...应用于整个序列std::forward<Args>(args)，而不仅仅是(args)，例如？
浏览 2提问于2011-08-12得票数 7
回答已采纳
在下面的代码片段中，return s给出了警告local variable 's' will be copied despite being returned by name [-Wreturn-std-move]。为什么是这种情况？
我使用这个lambda函数的目标是获得输入字符串的所有权，然后通过RVO或move语义修改后返回它。我真的很想避免任何复制。
const auto to_upper = [](std::string&& s) {
std::transform(s.begin(), s.end(), s.begin(),
浏览 12提问于2021-03-24得票数 6
回答已采纳
试图理解使用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
回答已采纳
在C++17中，将成为可能。基本上，这段代码将会编译：
std::pair p(2, 4.5); // deduces to std::pair<int, double> p(2, 4.5);
std::tuple t(4, 3, 2.5); // same as auto t = std::make_tuple(4, 3, 2.5);
因此，假设下面的代码：
template<typename... Ts>
struct Foo
{
Foo(Ts&&... ts) :
ts{std::forward_as_tuple(t
浏览 12提问于2016-08-25得票数 8
回答已采纳
2回答
编写缩写函数模板的最佳实践是什么？
我理解，自C++20以来，以下代码是有效的：
void f(auto&& val) {...}
是否有必要使用解密(Auto)作为这类函数的返回类型？特别是，下面的代码是编写缩写函数模板的正确方法吗？
decltype(auto) f(auto&& val) {return std::forward<decltype(val)>(val+=2);}
我该如何专攻上述功能？
//something like this?:
template<> decltype(auto) f<MyCl
浏览 3提问于2020-06-30得票数 2
回答已采纳
1回答
我非常高兴地发现了，这使得处理参数包更加容易。
(void)std::initializer_list{(ref(f)((Ts&&)a),0)...}，F，class...Ts> F for_each_arg(F f，Ts&.a){返回class...Ts> f；}
然而，我对它的正确用法感到困惑。有许多论点需要完全转发，但我是否执行了任何不必要的转发？
由于过度使用代码，阅读代码变得更加困难。
struct UselessContainer
{
// Expects a perfectly-forwarded item to emplace
浏览 3提问于2015-02-01得票数 3
回答已采纳
这些功能是否等效？
template <class T>
void foo(T && t)
{
bar(std::forward<T>(t));
}
template <class T>
void foo2(T && t)
{
bar(std::forward<decltype(t)>(t));
}
template <class T>
void foo3(T && t)
{
bar(std::forward(t));
}
如果是的话，我可以一直使用这个宏进行
浏览 9提问于2014-04-27得票数 23
回答已采纳
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
回答已采纳
我总是读到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
回答已采纳
3回答
构建函数列表类的功能的完美转发
、、、、
请考虑以下构建类存储函数的代码。
// Function list class
template <class... F>
struct function_list
{
template <class... G>
constexpr function_list(G&&... g) noexcept
: _f{std::forward<G>(g)...}
{
}
std::tuple</* F... OR F&&... */> _f;
};
// Function l
浏览 3提问于2017-02-03得票数 3
回答已采纳
在C++20中，以下函数不是格式错误的：
void f(auto&&... args) { /*...*/ }
而且，如果没有错误的格式，是否有一种方法(不修改签名)在正文中以与以下功能完全相同的方式转发参数：
template<typename... Args>
void f(Args&&... args) {
g(std::forward<Args>(args)...);
}
如果是这样的话，什么应该取代使用Args作为std::forward的模板参数？
浏览 1提问于2021-01-28得票数 4
回答已采纳
考虑一下这门课：
template<typename T> struct pooled_resource: T{
template<typename... Args> pooled_resource(std::list<T>& pool, Args&&... args):
T(select_resource(pool, std::forward<Args>(args)...)), pool(pool){
if(!pool.empty()) pool.pop_front();
}
~pooled_resour
浏览 2提问于2015-10-04得票数 0
回答已采纳
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
回答已采纳
#include <vector>
using namespace std;
vector<int> f()
{
return{};
}
// Update: Below is not compilable
void g(vector<int>)
{}
// Update: Below is the my initial intent.
/*
void g(const vector<int>&)
{}
*/
void g(vector<int>&&)
{}
int main()
{
浏览 4提问于2017-02-27得票数 1
回答已采纳
2回答
我将重点介绍一下，在线程中，线程的构造函数是用下面的内容定义的。
template<class _Fn,
class... _Args>
explicit thread(_Fn&& _Fx, _Args&&... _Ax)
{ // construct with _Fx(_Ax...)
_Launch(&_Thr,
_STD bind(_Decay_copy(_STD forward<_Fn>(_Fx)),
_Decay_copy(_STD forwar
浏览 3提问于2014-06-24得票数 2
回答已采纳
1回答
转发函数指针
、、、
我惊讶地发现，显然std::forward不能与任意类型一起使用，尽管文档表明。
#include <utility>
template<typename T>
void bar(T&&);
template<typename T>
void foo(T&& v) {
bar(std::forward(v));
}
int main() {
foo(main);
}
产生
forward.cc: In instantiation of 'void foo(T&&) [with T
浏览 3提问于2014-02-21得票数 2
回答已采纳
3回答
我有一个模板，需要在noexcept说明符中多次使用从用户提供的类型noexcept派生出来的类型。在下面的示例中，我需要多次使用腐朽类型的T。天真的做法是：
// in this case
template <typename T>
void foo(T&& t) noexcept( noexcept(typename std::decay<T>::type(std::forward<T>(t)))
&& noexcept(std::declval<typenam
浏览 2提问于2013-09-27得票数 0
回答已采纳
如果我编码:-
class B; //some B.h has definition of B
std::make_unique<B>();
Resharper会警告我，我应该包括B.h。(正确)
类型'B‘不完整
但是，如果我试图模仿std::unique_ptr<T>的代码并将其放入Test.h中：-
Test.h
//inside class Test
template<class _Ty,
class... _Types> inline
typename std::enable_if<!std::is_array<_
浏览 2提问于2017-03-12得票数 1
回答已采纳
我试图为不可复制、不可移动的类制作一个可移动的包装器，但是我在将一个const std::string变量传递给构造函数时遇到了问题。下面的最小示例产生以下错误：
#include <iostream>
#include <memory>
#include <string>
#include <utility>
struct X {
std::string x;
X(const std::string &x) : x(x) {}
X(const X &x) = delete;
X(X &
浏览 0提问于2018-01-29得票数 12
回答已采纳
1回答
变元模板的完美转发
、、、、
我目前正在使用一些新的C++17特性，特别是std::optional，我决定尝试使用各种模板模板来开发一个最小的查找函数。到目前为止，这就是我所拥有的：
template <template <typename> typename Opt,
typename T>
Opt<T> optional_min(Opt<T>&& opt) {
return std::forward<Opt<T>>(opt);
}
template <template <typename
浏览 0提问于2018-06-11得票数 1
回答已采纳
我使用几种方法(出于好奇)编写了在std::tuple上迭代的代码。我成功地使用了std::enable_if方法、带有模板专门化的静态类函数、模板函数重载等。对于函数重载，我编写了以下内容：
template<size_t N> struct SizeT{};
template<typename Tuple>
void print(Tuple, SizeT<0>){}
template<typename Tuple, size_t N>
void print(Tuple t, SizeT<N>)
{
print(t,Si
浏览 1提问于2013-11-18得票数 2
回答已采纳
1回答
我想知道模板化函数的部分规范是否是C++标准的一部分，或者这是否是编译器特有的东西。
通过部分规范，我的意思是只指定编译器不能推断的类型。因此，如果我有一个模板函数'f‘，它有3种类型，其中一种用在参数中，可以推导出来，我可能会用f<type, type>(parameter)的形式调用'f’
下面是一个例子：
#include <iostream>
#include <tuple>
#include <string>
template<class A, class B, class C>
std::tuple<
浏览 2提问于2012-11-26得票数 15
回答已采纳
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
回答已采纳
3回答
在lambda中实现完美的转发？
、、、、
使用一个函数，你可以这样写：
template <class T> void f(T&& x) {myfunction(std::forward<T>(x));}
但是对于lambda，我们没有T
auto f = [](auto&& x){myfunction(std::forward</*?*/>(x));}
如何在lambda中做完美的转发？decltype(x)是否可以作为std::forward中的类型使用
浏览 29提问于2017-03-15得票数 17
回答已采纳
我正在尝试学习一些基本的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
回答已采纳
我了解了SFINAE原理及其各种用途。然后，我编写了下面的程序，它与gcc一起编译，但不使用msvc和clang。。
#include <iostream>
#include <type_traits>
template <typename T> class Container {
public:
template<typename U = T>
std::enable_if_t<std::is_same_v<T, int>> foo(const T&)
浏览 8提问于2022-11-25得票数 7
1回答
为什么这个模板推理失败？
、、、
这段代码不会用clang++ 6.0或g++4.9.1编译(代码没有任何意义，但这是使其发生的最小示例)：
#include <forward_list>
template<typename T>
T getItem(typename std::forward_list<T>::const_iterator it) {
return *it;
}
template<typename T>
void foo() {
std::forward_list<T> list;
auto item = getItem(
浏览 4提问于2014-11-10得票数 2
回答已采纳
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
回答已采纳
3回答
理解性病：：向前
、、
编译器无法推断std::forward的模板参数的原因
我是说：
#include <memory>
#include <iostream>
struct X{};
struct A{
A( const X& ) { std::cout << "cpy ctor\n"; }
A( X&& ) { std::cout << "move ctor\n"; }
};
X foo() { return {}; }
template<typename T,typename
浏览 5提问于2015-08-25得票数 9
回答已采纳
1回答
下面是我的代码：
#include <stdio.h>
#include <utility>
#include <tuple>
template <typename Obj, typename Method, typename Args, size_t... Ns>
inline void DispatchToMethodImpl(const Obj& obj, Method method, Args&& args,
std::index_sequence
浏览 5提问于2021-09-27得票数 0
我试图编写一个函数来转发变量模板函数的参数，类似于std::invoke。以下是代码：
#include <functional>
template<class... Args>
void f(Args&&... args) { }
template<template<class...> class F, class... Args>
void invoke(F<Args...> f, Args&&... args) {
f(std::forward<decltype(args)>
浏览 0提问于2018-05-04得票数 4
回答已采纳
2回答
我目前正在学习c++的完美转发，我遇到了一些让我感到困惑的东西。很确定这是件蠢事。当我在lvalue上使用std::forward时，它使用rvalue函数。这是个很糟糕的解释所以我要给你看代码。
#include <iostream>
void check(int&& other) {
std::cout << "Rvalue" << std::endl;
}
void check(int& other) {
std::cout << "Lvalue" <<
浏览 8提问于2021-05-20得票数 1
回答已采纳
所以 (就像我家里的VS2012和SP1 (+11月包)一样)，而。谁能告诉我C++11在VS中缺少什么功能，有什么解决方法吗？
#include <iostream>
#include <utility>
#include <type_traits>
struct A {
int x;
void a() {
std::cout << "an a! " << x << "\n";
}
};
struct B {
double x;
浏览 1提问于2013-02-01得票数 1
回答已采纳
我设置了一个测试用例来学习完美转发。
std::string inner(const std::string& str ) {
return "const std::string&";
}
std::string inner(std::string& str ) {
return "std::string&";
}
std::string inner(const std::string&& str ) {
return "const std::string&&";
}
浏览 0提问于2012-04-24得票数 13
我有以下模板类(简化为只包含相关部分)，它使用一个名为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
回答已采纳
1回答
我试图创建一个简单的对象管理器，它包含一个对象列表，在main.cpp中，我试图将“目标”放入列表中，但是我收到了一个错误:无法将参数1从'Target *‘转换为'int’。我不明白为什么会发生错误？
另外，有什么区别
manager.createObject<Target, 5>()
和
manager.createObject<Target>(5)
它们是一样的吗，即我是否正确地调用了这个函数？
// ObjectManager.h
class ObjectManager
{
std::vector<std::shared_ptr&l
浏览 1提问于2017-07-26得票数 0
回答已采纳
我正在用C++编写一个自定义的多层感知器(MLP)实现。除了最后一个层之外，所有的层都共享一个激活函数foo，最后一个层具有一个单独的激活bar。我试图编写我的代码，以便它能够处理这种类型的模型，并且有不同的层数，比如在。不幸的是，正如所写的那样，我不得不为激活函数硬编码参数包，因此链接中的代码只为N = 5编译。
是否有一种方法可以从两个激活函数中创建一个自定义参数包，它能够“左扩展”第一个参数，这样我就可以编译上面的代码了(在适当地更新了对computeIndexedLayers的computeMlp调用之后)？具体来说，我正在考虑一些实用程序，它可以产生参数包，例如：
template
浏览 12提问于2022-06-11得票数 2
回答已采纳
在O类中，我有模板函数test2
struct A{int value;};
struct O{
A value;
template<typename Args>
static void test2(Args &&args){
std::cout << std::endl << "!!!" << std::is_rvalue_reference<decltype(args)>::value << std::endl;
}
};
我想从另一个
浏览 2提问于2014-06-24得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
