是否可以仅从std::any使用std::reference_wrapper创建std::any？
可以使用std::reference_wrapper创建std::any，但需要注意一些限制和注意事项。
std::reference_wrapper是一个包装器，用于在不拷贝对象的情况下传递引用。它提供了一个类似引用的接口，可以通过解引用操作符（*）来访问被包装的对象。
在使用std::reference_wrapper创建std::any时，需要注意以下几点：
- std::reference_wrapper只能包装可复制的类型，因为std::any要求其存储的对象是可复制的。如果尝试包装不可复制的类型，将会导致编译错误。
- 创建std::any时，需要显式指定std::reference_wrapper的类型，以便std::any知道如何处理它。例如，可以使用std::any(std::ref(obj))来创建std::any对象，其中obj是被包装的对象。
- 访问std::reference_wrapper包装的对象时，需要使用std::any_cast来提取出原始对象的引用。例如，可以使用std::any_cast<T&>(anyObj)来获取被包装对象的引用，其中T是原始对象的类型。
- 需要注意的是，std::reference_wrapper只是对原始对象的引用进行了包装，并没有拷贝对象本身。因此，在使用std::reference_wrapper创建std::any时，需要确保原始对象的生命周期足够长，以避免悬空引用的问题。
总结起来，使用std::reference_wrapper创建std::any可以实现对引用类型的包装和传递，但需要注意类型的可复制性和引用的生命周期。在某些情况下，使用std::reference_wrapper可以避免不必要的对象拷贝，提高性能和效率。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（云原生）：https://cloud.tencent.com/product/scf
- 腾讯云云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云数据库（TencentDB）：https://cloud.tencent.com/product/cdb
- 腾讯云人工智能（AI）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（IoT）：https://cloud.tencent.com/product/iot
- 腾讯云移动开发（移动推送）：https://cloud.tencent.com/product/umeng
- 腾讯云对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（BCS）：https://cloud.tencent.com/product/bcs
- 腾讯云虚拟专用网络（VPC）：https://cloud.tencent.com/product/vpc
- 腾讯云安全产品（云安全中心）：https://cloud.tencent.com/product/ssc
相关·内容
比方说，我有一个std::any，其中存储了类型T。是否可以创建另一个包含std::reference_wrapper<const T>类型的std::any？喜欢 std::any original = std::string("Test string");
std::any reference;
// Magic here
auto ref = std::any_cast<std::reference_wrapper<const std::string>>(reference); // Works
浏览 51提问于2020-01-09得票数 1
我有点卡住了。
尝试从模板类内部检查参数是否为引用类型
它似乎在函数中起作用。
但是在我的函数包装器中，它总是返回true。
#include <vector>
#include <any>
template <class T>
T CallFunction(const std::vector<std::any>& args) {
for (size_t i = args.size(); i > 0; i--) {
std::cout << std::boolalpha << std
浏览 0提问于2020-06-05得票数 3
#include <iostream>
#include <vector>
#include <string>
#include <any>
using namespace std;
template <typename T>
class MyVector {
private:
int n;
T* data;
public:
MyVector() {
n = 0;
data = nullptr;
cout << "MyVector defau
浏览 3提问于2022-03-25得票数 1
回答已采纳
1回答
我正试图解决昨天提出的基于的问题。
我已经修改了给定的代码，使其使用std::any而不是void*。我目前拥有的代码如下：
#include <iostream>
#include <map>
#include <vector>
#include <any>
#include <typeindex>
struct cStreet{};
struct cHouse{};
struct cComputer{};
struct cBook{};
class cPlayer
{
public:
struct Properties
浏览 7提问于2021-12-17得票数 0
回答已采纳
我正在尝试创建一个Invoker对象，它同时存储一个函子和这个函子的一组参数--所有的值(用于线程处理)。Invoker::operator()()将使用复制的参数调用存储的函子。
到目前为止，一切都很好，直到有人尝试使用auto&使用std::ref(variable)传递一个参数。具体来说，这段代码应该可以工作，但是它不使用给定的错误消息进行编译：
int var = 0;
Invoker{
[](auto& r) {
printf("%d\n", r);
}, std::ref(var)
}();
我希望它的工作方式类似于s
浏览 0提问于2018-02-23得票数 0
我正在尝试初始化一个元组(使用std::make_tuple)，我也想在其中存储一个std::type_info，但是我不知道为什么由于某种原因这段简单的代码无法编译。
我试着运行以下代码：
#include <iostream>
#include <string>
#include <tuple>
#include <typeinfo>
#include <any>
int main()
{
std::tuple<std::type_info, int, std::any> tpl = std::ma
浏览 5提问于2022-12-01得票数 0
我试图理解以下代码的结果：
template<typename KeyTypeT, typename ValueTypeT>
class MapWrapper {
std::any _container;
MapWrapper() {
_container = std::map<KeyTypeT, ValueTypeT>();
}
void insert(KeyTypeT key, ValueTypeT value) {
auto originalMap = std::any_cast<std::m
浏览 1提问于2018-09-03得票数 3
回答已采纳
3回答
我有一个接受std：：可选参数的函数
void foo(const std::optional<T>& opt);
但是复制T是很昂贵的。
这是否会创建T的副本
如果是这样，我怎么能不创建副本呢？
浏览 15提问于2017-07-23得票数 4
Book和Article是从Medium派生的类。
为什么在书目中插入Medium / Book / Article时会出现此错误？
error: no matching function for call to '**std::reference_wrapper<Medium>::reference_wrapper()**
main.cc
#include <iostream>
using namespace std;
#include "Bibliography.h"
#include "Medium.h"
#inc
浏览 6提问于2017-12-16得票数 0
回答已采纳
2回答
我找到了这个，但我需要一个不依赖于boost的实现，我试着将它转换为只使用boost，但我遇到了一些麻烦。
这是我想出来的：
#include <boost/any.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/unordered_map.hpp>
struct type_info_hash {
std::size_t operator()(std:
浏览 0提问于2012-11-15得票数 5
回答已采纳
我有一个C++类，它的一个字段是一组std：：对象。我想编写自己的比较函数，或者让用户指定一个。在C++11中，有一种新的方法来处理泛型函数类型: std::function。它与函数指针、成员函数指针、lambda函数等一起工作。
我试着写一个简单的实验程序，但它总是崩溃，即使我做了C++11维基百科上的文章建议。也许我只是不明白std::function和std::ref应该如何使用。
无论如何，重点是当我从一个简单的lambda函数创建一个std：：函数并使其成为类成员时，类的大小增加了22。当我从指向全局函数的指针创建std::function时，这个std：：function的siz
浏览 0提问于2013-02-15得票数 0
回答已采纳
我正在查看Adobe分发的文件的代码：
我感兴趣的部分代码是：
struct any_json_helper_t {
typedef any value_type;
typedef string key_type;
typedef string string_type;
typedef unordered_map<key_type, value_type> object_
浏览 1提问于2017-04-04得票数 1
回答已采纳
4回答
多态对象数组
、、、、
我通常会发现需要创建多态对象的数组或向量。我通常更喜欢使用对基类的引用，而不是智能指针，因为它们更简单。
数组和向量被禁止包含原始引用，因此我倾向于使用指向基类的智能指针。但是，也可以选择使用std::reference_wrapper：
从文档中可以看出，这就是它的预期用途之一，但是当出现包含多态对象的数组的主题时，常见的建议似乎是使用智能指针而不是std::reference_wrapper。
我唯一的想法是，智能指针可以处理对象的生命周期稍微整洁一点吗？
TL:为什么在创建多态对象数组时，智能指针(如std::unique_ptr )似乎比std::reference_wrapper更可
浏览 1提问于2018-09-07得票数 12
回答已采纳
写这个表达式在语义上有什么区别吗？
std::tie( x, y, z )
下面的表达式呢？
std::make_tuple( std::ref(x), std::ref(y), std::ref(z) )
如果是这样，有什么不同？
顺便说一下，这个问题与的问题不同，因为引用元组不是通过std::ref创建的，而是通过显式指定类型来创建的。
浏览 89提问于2016-04-25得票数 22
回答已采纳
1回答
当我在std::unordered_map中使用一个自定义类作为键时，发生了一个有趣的错误。我为这个自定义类实现了一个散列函数。
如果我像这样创建了一个std::unordered_map，那么一切都运行得很好：
std::unordered_map <Component, int> myMap;
但是，如果我创建一个键是引用的std::unordered_map，它会抱怨这种类型没有实现的散列函数：
std::unordered_map <Component&, int> myMap;
错误3错误C2338: C++标准没有为这种类型提供散列。
你知
浏览 4提问于2015-12-28得票数 3
回答已采纳
1回答
我对下面的代码感到困惑，其中类Baz允许通过代理类Bar访问其内部数据
struct Foo{};
template<class T>
struct Bar
{
Bar(T &val_): val(val_) {}
T &val;
};
struct Baz
{
Bar<const Foo> get() const {return Bar<const Foo>(foo);}
Bar<Foo> get() {return Bar<Foo> (fo
浏览 1提问于2020-07-15得票数 0
回答已采纳
template <typename T>
void myswap(T a,T b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
int m(20),n(30);
myswap(ref(m),ref(n));
//m is still 20 and n is still 30
}
为什么m和n的值没有互换？将包装在std::ref中的值传递给增量函数会导致原始变量(调用增量函数的堆栈框架中的变量)中的值发生变化。或者，std::ref的使用是否受到限制？
浏览 0提问于2015-12-11得票数 5
我希望std::reference_wrapper在将non转换为const方面充当引用，例如：
int a = 10;
int& refA = a;
const int& constRefA = refA;
下面的代码在MSVC和GCC中编译并运行良好，但在Clang上没有。我只是不明白为什么，是UB，还是Clang编译器的问题？
#include <functional>
#include <optional>
int main()
{
int a = 10;
std::reference_wrapper<int> r
浏览 1提问于2021-02-01得票数 2
我有一个类，它包含一个拷贝构造函数和一个接受std::reference_wrapper的构造函数。
#include <functional>
#include <iostream>
class Class {
public:
Class() {
std::cout << "Class()" << std::endl;
}
Class(Class const &) {
std::cout << "Class(Class const &)
浏览 3提问于2018-05-02得票数 8
给予：
#include <iostream>
#include <functional>
template<class T> // Just for overloading purposes
struct behaviour1 : std::reference_wrapper<T const>
{
using base_t = std::reference_wrapper<T const>;
using base_t::base_t;
// This wrapper will never outlive
浏览 2提问于2017-10-26得票数 2
回答已采纳
我正在从事一个C++17项目，并在那里使用std::any。下面给出了一个最小的可重复的例子，以供参考，解释我想要达到的目标。
#include <any>
#include <vector>
#include <iostream>
int main()
{
std::vector<int> vec{1,2,3};
std::any anything = vec;
// anything.push_back(4);//i want to add an element into vector vec, us
浏览 16提问于2021-12-16得票数 -2
回答已采纳
最近被发布了(恭喜！)我关心的是gsl::not_null类型。如中所述
以避免取消引用nullptr错误。通过避免对nullptr的冗余检查来提高性能。
..。
通过在源中说明意图，实现者和工具可以提供更好的诊断，例如通过静态分析查找某些类型的错误，并执行优化，例如删除分支和空测试。
意图是明确的。然而，我们已经有了一个语言特性。不能为空的指针称为引用。虽然引用一旦创建就不能反弹，这个问题通过std::reference_wrapper解决了。
我看到gsl::not_null和std::reference_wrapper的主要区别在于，后者只能用来代替指针，而前者可以用于任何nul
浏览 8提问于2015-10-23得票数 71
回答已采纳
我在玩纸牌游戏。
在这场比赛中，我有球员，他们是一个团队的成员(每队2名球员)，他们可以加入一个大厅。
大厅里有一名队员，两队都有一名队员。我想直接对球员进行迭代，而不是每次都要通过球队。
相关的C++代码：
obby.h
class Lobby {
public:
Lobby(std::string const& name, std::vector<Team> const& teams = std::vector<Team>());
Lobby(){};
~Lobby();
// give cards to all
浏览 1提问于2014-10-19得票数 1
回答已采纳
在C++11标准中，它声明(参见，另见标准的20.4.2.4节)
template< class... Types >
tuple<VTypes...> make_tuple( Types&&... args );
创建元组对象，从参数类型推断目标类型。
对于Types...中的每个Types...，Vtypes...中的对应类型Vi是std::decay<Ti>::type，除非std::decay的应用在std::reference_wrapper<X>中导致了某种类型的X，在这种情况下，推导出的类型是X&。
浏览 5提问于2013-09-27得票数 10
回答已采纳
如何将std::transform与包含std::reference_wrapper类型对象的容器结合使用？当从const std::vector<std::reference_wrapper<const float>>读取和写入std::vector<float>时，一切正常，但是如果我试图写入std::vector<std::reference_wrapper<float>>，它不会编译，从而导致错误
/usr/include/c++/5/bit/stl_algo.h:4214:错误:使用已删除的函数>'std::
浏览 2提问于2018-02-21得票数 0
回答已采纳
struct Foo{};
std::make_unique<Foo>和std::make_unique<std::reference_wrapper<Foo>>之间的区别是什么
浏览 2提问于2019-03-28得票数 0
我最近一直潜入C++，我一直在尝试。我遇到了一个我似乎无法解决的问题。我猜这涉及到我不了解C++是如何演绎类型的，但我不确定。下面是工作的代码
template <typename T>
auto most_frequent_element(const std::vector<std::reference_wrapper<T>> &vector) -> boost::optional<std::pair<const std::reference_wrapper<T>, size_t>> {
if (v
浏览 4提问于2015-09-11得票数 2
回答已采纳
我一直在努力理解std::reference_wrapper，的实现，如下所示：
namespace detail {
template <class T> constexpr T& FUN(T& t) noexcept { return t; }
template <class T> void FUN(T&&) = delete;
}
template <class T>
class reference_wrapper {
public:
// types
typedef T type;
// const
浏览 11提问于2022-01-02得票数 6
回答已采纳
我试图用std::bind来模拟C++11 lambda中的完美/移动捕获。在下面的函数中，我希望通过lvalue或rvalue传递带有可变运算符()的处理程序，根据需要复制或移动它并调用它。
template <typename Handler>
void foo (Handler&& h)
{
std::bind (
[] (Handler& h) { h (); },
std::forward<Handler> (h)
) ();
}
这段代码在大多数情况下运行良好，但是当我用std::ref
浏览 0提问于2015-12-17得票数 4
回答已采纳
小心点:我是GCC 4.1.2。我们在一个专有的嵌入式平台上。我们不能更新到一个新的编译器。所以C++03 + TR1就是了。
我们在某个地方有这样的功能：
template<typename T>
void foo(const boost::any& x)
{
bar(boost::any_cast<T>(x));
}
然后在绑定表达式中使用：
std::tr1::bind( &foo<T>, _1);
这会产生以下错误：
error: call of overloaded 'ref(const boost::any&)
浏览 0提问于2013-12-12得票数 6
回答已采纳
2回答
我想在std::vector中存储一个对象列表，但是这些对象包含一个引用，不能分配给它。然而，我可以复制-构造对象。
我能想到的唯一选择是使用指针包装对象，并在需要分配指针时重新分配指针，但这一方法的语法将大大降低可读性，特别是在使用迭代器时，我更喜欢另一种选择。
不管用：
std::vector<MyObject> myVector;
//fill the vector
//...
myVector[1] = object1;
智能指针牺牲可读性：
std::vector<std::unique_ptr<MyObject>> ptrVector;
//fi
浏览 2提问于2012-10-16得票数 5
回答已采纳
下面是两种不同类型的std::vector，作为示例：
std::vector<std::reference_wrapper<MyClass>> rv;
std::vector<MyClass> v;
在它们之间进行赋值的一种可能方式是：
for (const auto& mc : rv) {
v.push_back(mc.get());
}
它起作用了。但是很难看，而且可能很慢。与比较相同：
bool is_same(std::vector<MyClass>& v, std::vector<std::referen
浏览 10提问于2016-12-27得票数 3
1回答
在编写clang插件时，我注意到llvm::cl::opt<T>类型的对象不能转换为std::any，即以下代码段不编译：
#include <any>
#include <string>
#include "llvm/Support/CommandLine.h"
int main()
{
llvm::cl::opt<std::string> opt("o");
std::any opt_any = opt; // doesn't work!
}
我想知道为什么在这个特定的实例中这是不可能的，以
浏览 2提问于2020-07-08得票数 0
回答已采纳
5回答
假设有一些数据结构：
typedef struct {
std::string s;
int i;
} data;
如果我在data.s类型的映射中添加data实例时使用字段std::map<std::string&, data>作为键，那么字符串是否会被复制？因为引用将变得无效，所以删除映射的元素安全吗？
同样，这些问题的答案也适用于unordered_map
编辑：
这是我目前的解决方案..。但是将迭代器添加到映射中是很难看的：
typedef struct {
const std::string* s;
int i;
} data;
浏览 5提问于2010-07-13得票数 16
回答已采纳
1回答
我正在用C++11线程构建一个应用程序，但我似乎无法让它在MacOSX 10.9上使用clang++。下面是我能找到的最简单的导致这些问题的例子：
#include <thread>
#include <iostream>
class Functor {
public:
Functor() = default;
Functor (const Functor& ) = delete;
void execute () {
std::cerr << "running in thread\n";
浏览 3提问于2014-11-24得票数 5
回答已采纳
我正在尝试理解std::ref是如何工作的。
#include <functional>
#include <iostream>
template <class C>
void func(C c){
c += 1;
}
int main(){
int x{3};
std::cout << x << std::endl;
func(x);
std::cout << x << std::endl;
func(std::ref(x));
std::cout
浏览 1提问于2013-05-14得票数 17
回答已采纳
1回答
下面的代码类似于这个答案Why can't I make a vector of references? class A
{
public:
A(int x) : _x(x)
{
std::cout << "A : ctor\n";
}
void func()
{
std::cout << "I am func \n";
}
int getval()
{
return _x;
}
priva
浏览 9提问于2020-07-18得票数 2
回答已采纳
类拥有一个类型为U的对象。通过一种方法，它使用getter将该对象公开为const U& (并不便宜，不需要修改)。
现在，一个客户想要利用这个API。他希望使用U实例作为复杂对象的一部分(它对更改API对象不感兴趣)。因此，他至少有以下选项:创建一个以T为参数的类const U&和一个类型为const U&的私有字段，其中构造函数存储API的实例。这有一个极端的缺点，就是使类的实例非常不灵活(例如，不使用std：：vectors进行管理)，这是不需要的。
不久前，我发现还可以使用std::reference_wrapper<const U>来存储const
浏览 0提问于2019-01-16得票数 0
回答已采纳
我想知道是否可以在unordered_map容器中使用对象引用作为C++中的键。
#include <unordered_map>
class Object {
int value;
};
struct object_hash {
inline size_t operator()(const Object& o) const { return 0; }
};
std::unordered_map<Object&, int, object_hash> map;
在试图编译这个简单的代码段时，我发现了一些有关方法重新定义的错误：
与libc
浏览 2提问于2012-05-22得票数 12
回答已采纳
2回答
我得到了一个向量std::vector<MyClass> myclass_vec(10)，其中包含10个初始化的MyClass对象。现在，我想循环这个向量，并将对每个MyClass对象的引用存储在另一个向量std::vector<MyClass> myclass_vec_refs中。我之所以要存储引用，是因为我不需要复制对象，显然，引用的对象与myclass_vec中的对象相同。
出于某种原因，这并不是一个有抱负的人。我必须像这样声明std::vector<&MyClass> myclass_vec_refs吗？
当我在这里查看其他问题时，我读到了关
浏览 4提问于2016-07-01得票数 0
回答已采纳
我在类层次结构中有一堆对象，并希望使用对这些对象的引用作为映射中的键来创建一个std::map。看起来这正是std::reference_wrapper所需要的，但我似乎不能让它工作。到目前为止，我已经尝试了：
class Object { // base class of my hierarchy
// most details unimportant
public
virtual bool operator< (const Object &) const; // comparison operator
};
std::map<std::referen
浏览 0提问于2012-02-04得票数 10
回答已采纳
我有一个引用类型的vector，包装在reference_wrapper中。由于我需要按顺序填充这个容器，所以我试图为容器设置一个初始大小：
vector<std::reference_wrapper<T>> v(5);
v[3] = ..
v[2] = ..
v[4] = ..
v[5] = ..
v[1] = ..
这样编译时出错，如下所示：
error: no matching function for call to ‘std::reference_wrapper<int>::reference_wrapper()’
是否有解决办法使这一工作，或我
浏览 7提问于2014-09-19得票数 3
回答已采纳
是否可以根据编译时信息有条件地选择lambda的捕获方法？例如..。
auto monad = [](auto && captive) {
return [(?)captive = std::forward<decltype(captive)>(captive)](auto && a) {
return 1;
};
};
如果decltype(captive)是一个std::reference_wrapper，我希望通过引用捕获，而其他所有内容都通过值捕获。
浏览 3提问于2014-11-26得票数 6
1回答
我有一个引用的结构和一个该结构的数组，我想按该结构的某个组件对数组进行排序，但是使用std::sort在Visual Studio上提供了一个foo &foo::operator=(const foo &) attempting to reference a deleted function error
struct foo {
double &x, &y;
};
foo arr[10];
std::sort(arr, arr + 10, [](const foo &a, const foo &b){ return a.x <
浏览 0提问于2019-11-17得票数 0
#include <functional>
#include <type_traits>
template<typename T>
requires (!std::is_void_v<T>)
struct A {};
int main()
{
A<void>* p1{}; // compile error as expected.
std::reference_wrapper<void>* p2{}; // no expected compile err
浏览 5提问于2021-07-04得票数 0
回答已采纳
我正在尝试理解std::reference_wrapper。
下面的代码显示引用包装的行为与引用并不完全相同。
#include <iostream>
#include <vector>
#include <functional>
int main()
{
std::vector<int> numbers = {1, 3, 0, -8, 5, 3, 1};
auto referenceWrapper = std::ref(numbers);
std::vector<int>& reference =
浏览 1提问于2013-08-08得票数 48
回答已采纳
我有一些类Foo和一个std::list<std::reference_wrapper<Foo>>，并且希望使用一个基于范围的for循环来迭代它的元素：
#include <list>
#include <functional>
#include <iostream>
class Foo {
public:
Foo(int a) : a(a) {}
int a;
};
int main() {
std::list<Foo> ls = {{1},{2},{3},{4}};
std::li
浏览 9提问于2021-08-01得票数 2
展示了使用std::ref/std::cref将参数传递给std::bind的方式，看起来std::bind是通过引用来获取参数，而在现实中则是按值取所有参数。
只看这个例子，我也可能不知道std::reference_wrapper的存在，而std::ref只是一个允许链接示例所显示的行为的函数。
这就是我所说的std::ref在这个问题的标题中的意思，以及下面的内容。
主要是为了好玩，我尝试过自己实现std::ref，我想出了以下几点：
template<typename T>
struct ref_wrapper {
ref_wrapper(T& t) : r
浏览 8提问于2021-01-08得票数 1
回答已采纳
我尝试在我的C++项目中包含一个python插件系统。为此，我使用了boost (1.54)。
我可能有一个编译问题，我不知道它的原因是什么，或者可能的修复方法是什么：
In file included from /usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp:52:0,
from /usr/include/boost/python/object/value_holder.hpp:50,
from /usr/include/boost/pyt
浏览 1提问于2015-02-25得票数 0
我正在尝试这样做:维护两个字符串向量，其中一个向量存储值，第二个向量存储相同值的引用。我原以为使用boost::reference_wrapper可以做到这一点，但它似乎不会。我的平台是VisualC++ 2008。
std::vector<std::string> str_vec;
str_vec.push_back("abc");
str_vec.push_back("cde");
str_vec.push_back("fgh");
std::vector<boost::reference_wrapper<std::
浏览 2提问于2012-04-22得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
