Question

我希望能够从两者中分配boost::fusion::map个参考值：

boost::fusion::map个值，和
boost::fusion::map个参考文献。

这样做的正确（通用和惯用）方式是什么？

// Let:
using bf = boost::fusion;
struct A {}; struct B{};

// I have a map of references
using my_ref_map = bf::map<bf::pair<A, float&>, bf::pair<B, int&>>;

// and a map of values:
using my_val_map = bf::map<bf::pair<A, float>, bf::pair<B, int>>;

// Say I have two values and I make a map of references
float a; int b;
my_ref_map MyRefMap(bf::make_pair<A>(a), bf::make_pair<B>(b));

// Then I wanto to set a and b using both:
// a map of values:
my_val_map MyValMap(bf::make_pair<A>(2.0), bf::make_pair<B>(3))

// and a map of references:
float aSrc = 2.0; int bSrc = 3;
my_ref_map MyRefMap(bf::make_pair<A>(aSrc), bf::make_pair<B>(bSrc));

// ... some code ...  (see below for the things I've tried)

assert(a == 2.0 && b == 3);  // <- End result.

我尝试了以下内容：

bf::copy(MyValMap, MyRefMap);
// copy complains that bf::pair<A, float&> cannot be assigned 
// because its copy assignment operator is implicitly deleted.
// This is fine, I wasn't expecting copy to work here.

实施bf::zip_non_const（见下文），允许您修改地图并执行：

bf::for_each(bf::zip_non_const(MyRefMap, MyValMap), [](auto i) {
  bf::at_c<0>(i) = bf::at_c<1>(i); });
// This works but bf::zip returns const& for a reason:
// there has to be a better way.

这是我zip_non_const的实现：

namespace boost { namespace fusion {
// Boilerplate:
namespace result_of {
template<class... Ts> struct zip_non_const {
  using sequences = mpl::vector<Ts...>;
  using ref_params 
    = typename mpl::transform<sequences, add_reference<mpl::_> >::type;
  using type = zip_view<typename result_of::as_vector<ref_params>::type>;
};
}

// zip_non_const
template<class... Ts>
inline typename result_of::zip_non_const<Ts...>::type zip_non_const(Ts&&... ts)
{ return {fusion::vector<Ts&&...>(ts...)}; }

// swap for fusion types
template <class T> inline void swap(T&& lhs, T&& rhs) noexcept {
  using std::swap;
  std::remove_reference_t<T> tmp = lhs;
  lhs = rhs;
  rhs = tmp;
}

}  // namespace fusion
}  // namespace boost

Answer 1

fusion::map定义了允许分配的=运算符。这种情况在您将my_val_map分配给my_ref_map时效果很好，但是当分配在两个fusion::copy之间时，您遇到与my_ref_map相同的错误。在下面的代码中，我只是迭代第一个映射中的对，然后将数据分配给目标映射中的相应对。
重要的是目标映射具有正在复制的映射中存在的所有键，否则您将收到编译错误。（如果你有Map1=map<pair<A,int> >; Map2=map<pair<A,int>, pair<B,float> >;，你可以从Map1复制到Map2，但不能从Map2复制到Map1。）
Live Example

#include <iostream>

#include <boost/fusion/include/map.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/include/at_key.hpp>

namespace fusion = boost::fusion;
struct A {}; struct B{};

// I have a map of references
using my_ref_map = fusion::map<fusion::pair<A, float&>, fusion::pair<B, int&>>;

// and a map of values:
using my_val_map = fusion::map<fusion::pair<A, float>, fusion::pair<B, int>>;

template<typename MapOut>
struct map_assigner //you could use a c++14 lambda if your compiler supports it
{
    map_assigner(MapOut& map):map_out(map){}

    template <typename Pair>
    void operator()(const Pair& pair) const
    {
        fusion::at_key<typename Pair::first_type>(map_out) = pair.second;
    }

    MapOut& map_out;
};

template <typename MapIn, typename MapOut>
void my_copy(const MapIn& map_in, MapOut& map_out)
{
    fusion::for_each(map_in,map_assigner<MapOut>(map_out)); 
}


int main()
{

    // Say I have two values and I make a map of references
    float a=0.0f;
    int b=0;
    my_ref_map MyRefMap(fusion::make_pair<A,float&>(a), fusion::make_pair<B,int&>(b));

    // Then I wanto to set a and b using both:
    // a map of values:
    my_val_map MyValMap(fusion::make_pair<A>(2.0f), fusion::make_pair<B>(3));

    // and a map of references:
    float aSrc = 4.0f; int bSrc = 6;
    my_ref_map MyRefMap2(fusion::make_pair<A,float&>(aSrc), fusion::make_pair<B,int&>(bSrc));

    my_copy(MyValMap,MyRefMap);

    std::cout << "a=" << a << ", b=" << b << std::endl;  // <- End result.

    my_copy(MyRefMap2,MyRefMap);

    std::cout << "a=" << a << ", b=" << b << std::endl;  // <- End result.
}

从值/引用的映射中分配引用映射

1 个答案: