标签: reference-wrapper

我有一个本地std::vector<std::reference_wrapper<T> >,现在我想返回其元素的真实副本(即std::vector<T>).有没有比循环更好的方法？

例:

std::vector<T> foobar() {
    std::vector<std::reference_wrapper<T> > refsToLocals;
    /*
      do smth with refsToLocals
    */
    std::vector<T> copyOfLocals;
    for (auto local : refsToLocals)
        copyOfLocals.insert_back(local.get());
    return copyOfLocals;
}

考虑以下情况：我有足够的存储空间来托管a void *并因此就地构造一个指针。
是否可以保证相同的存储空间足够大，以便始终存储一个std::reference_wrapper？

某种（出于我的想法而写，只是为了理解我的意思）：

std::aligned_storage_t<sizeof(void *), alignof(void *)> storage;
// ...
int value = 0;
new (&storage) std::reference_wrapper<int>{value};

通过快速而肮脏的测试，我发现在我的机器上这是有效的，即与的大小std::reference_wrapper相符void *。但是，在不同平台上可能是这种情况。同时，我在标准中找不到关于和的大小的任何线索，std::reference_wrapper而且我想知道它的实现是否已定义或是否有任何保证。

为了提供上下文，我正在围绕不同类型（类似于std::any）的不透明包装器进行包装，该包装器执行小型对象优化以避免可能的分配。
收到时std::reference_wrapper，我想使用与用于区别sizeof(T) > sizeof(void *)其他情况的路径不同的路径。但是，我不知道我是否可以就地复制包装器的构造，或者在这种情况下是否还应该依靠分配。

我认为地图和reference_wrappers会变得容易,但我绊倒了一些奇怪的东西:

#include <map>
#include <functional>

int main(void) {
    std::map<int, std::reference_wrapper<const int>> mb;
    const int a = 5;
    mb[0] = std::cref(a);
}

这段代码给了我以下编译器错误:

In file included from c:/MinGW/x86_64-w64-mingw32/include/c++/bits/stl_map.h:63:0,
                 from c:/MinGW/x86_64-w64-mingw32/include/c++/map:61,
                 from ../test/main.cpp:9:
c:/MinGW/x86_64-w64-mingw32/include/c++/tuple: In instantiation of 'std::pair<_T1, _T2>::pair(std::tuple<_Args1 ...>&, std::tuple<_Args2 ...>&, std::_Index_tuple<_Indexes1 ...>, std::_Index_tuple<_Indexes2 ...>) [with _Args1 = {int&&}; long long unsigned int ..._Indexes1 = {0ull}; _Args2 = {}; long long unsigned int ..._Indexes2 = {}; _T1 = const int; _T2 = std::reference_wrapper<const int>]':
c:/MinGW/x86_64-w64-mingw32/include/c++/tuple:1083:63:   required from 'std::pair<_T1, _T2>::pair(std::piecewise_construct_t, std::tuple<_Args1 ...>, …

假设我们有一些可变参数模板,需要以std::reference_wrapper不同方式处理参数.我们怎样才能做到这一点？

请考虑以下代码:

#include <iostream>
#include <functional>

using namespace std;

template<class T>
void fun(T t) 
{ 
    t+=8;
}


int main()
{
    int i = 0;
    fun(ref(i));
    cout << i << endl;
}

此代码打印"8".我假设fun()中的t自动转换为int&.

但是,如果我取代t+=8用t=8,程序将无法编译.

为什么？

如何std::reference_wrapper通过他们持有的参考来比较两个？我想看看两个std::reference_wrappers 的引用是否相等.

编辑:对不起,混乱.我的意思是如何获取所指对象的地址并进行比较.

我有以下std::reference_wrapper用于类型(double)和用户定义类型(std::string)的构建.

为什么它们在流运算符的情况下表现不同？

#include<functional> //reference wrapper
#include<iostream>

void fd(double& d){}
void fs(std::string& s){}

int main(){

   double D = 5.;
   std::reference_wrapper<double> DR(D);
   std::cout << "DR = " << DR << std::endl; //ok 
   fd(DR); // ok

   std::string S = "hello";
   std::reference_wrapper<std::string> SR(S);
   std::cout << "SR = " << static_cast<std::string&>(SR) << std::endl; // ok
   std::cout << "SR = " << SR << std::endl; // error: invalid operands to binary expression ('basic_ostream<char, std::char_traits<char> >' and 'std::reference_wrapper<std::string>')
   fs(SR); // ok …

是

std::optional<std::reference_wrapper<some_type>>

是否符合C++ 17的标准(或草案)？

标准明确指出,std::optional对于参考类型来说是不正确的.但它包括reference_wrapper？

我有两个类，即“ Base”和“ Derived”，其中Derived类继承Base类。

然后是对派生类实例的引用的容器 ( std::vector< std::reference_wrapper< Derived > > myContainer)。

最后，我有一个作为std::vector< std::reference_wrapper< Base > >参数的函数。

如果我将容器（myContainer）传递给函数，它不会编译：

如果我更改容器来保存对 Base 的引用，一切都会正常工作，并且由于它是一个引用包装器，我相信，我仍然会具有我需要的多态行为。但这感觉不干净，因为我确信我的容器不会容纳除派生实例之外的任何东西。

同时，接受向量的函数应该适用于派生类和基类。

最小代码：

#include <vector>
#include <functional>

class Base
{ /*some virtual stuff*/ };

class Derived : public Base
{};

void Fun( std::vector< std::reference_wrapper< Base > > const & container )
{}

int main()
{
    std::vector< std::reference_wrapper< Derived > > myContainer;
    Fun( myContainer ); // Error: no viable conversion
    return 0;
} …

我无法弄清楚如何使用a 获得std::string引用.根据以下链接,我知道我需要超载.std::unordered_mapstd::reference_wrapperoperator==

为什么不能在`std :: reference_wrapper`s中推导出模板实例？

但是,我无法弄清楚如何编写operator==它将需要一个const std::reference_wrapper.如果包装器不是const,那就没问题了.

使用char代替std::string工作正常(不需要重载operator==).

码:

#include <iostream>
#include <unordered_map>
#include <functional>

bool operator==(const std::reference_wrapper<std::string> lhs,
                const std::reference_wrapper<std::string> rhs)
{
    return std::equal_to<std::string>()(lhs.get(), rhs.get());
}

int main(){
    char        chr('a');
    std::string str("b");
    int         num(1);

    // this works (char)
    std::unordered_map<std::reference_wrapper<char>, int, std::hash<char>> charMap;
    std::pair<std::reference_wrapper<char>, int> charPair(chr , num);
    charMap.insert(charPair);
    std::cout << "charMap works.  Output: " << charMap[chr] << std::endl;

    // does not work (std::string)
    std::unordered_map<std::reference_wrapper<std::string>, …