0

我有一个std::vector<double>我必须移动到一个boost::container::flat_set<double>。两个容器都是连续的，因此原则上对向量进行排序后，我可以将数据从一个容器移动到另一个容器。

有没有办法在这两个不同的容器之间移动整个数据？

请考虑到我想移动整个数据，而不是逐个元素。

我可以在相同类型的容器之间移动数据，但不能在不同容器之间移动。

std::vector<double>  v1 = ...
std::sort(v1.begin(), v1.end());

std::vector<double>  v2(std::move(v1)); // ok
boost::flat_set<double> f2(v1.begin(), v1.end()); // doesn't move, it copies
boost::flat_set<double> f3(std::move(v1)); // doesn't compile

似乎要使它起作用，flat_set应该有一个来自容器的移动构造函数.data()，其中指针是从参数中窃取的。

4

2 回答 2

1

我相信有一些方法可以验证两个容器中的数据对齐是否匹配并且memcpy可以使用（并且在不破坏的情况下清除源）存在并且也许有人会与我们分享它，但只要我们想使用 STL，就有一种方法：std::move_iterator. _ 它使您的容器构造函数移动元素而不是复制。虽然它不会从源容器中删除元素，但会留下它们stateless（例如，示例中的空字符串）。

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <boost/container/flat_set.hpp>

int main()
{   
    std::vector<std::string>  v1 = {"a","v","d"};
    std::sort(v1.begin(), v1.end());

    std::vector<std::string>  v2(std::move(v1)); // ok
    boost::container::flat_set<std::string> f1(std::make_move_iterator(v2.begin()), std::make_move_iterator(v2.end())); // moves, but does not remove elements from of source container


    for(auto& s : v1)
        std::cout << "'" << s << "'" << ' ';
    std::cout << " <- v1 \n";

    for(auto& s : v2)
        std::cout << "'" << s << "'" << ' ';
    std::cout << " <- v2 \n";

    for(auto& s : f1)
        std::cout << "'" << s << "'" << ' ';
    std::cout << " <- f1 \n";
}

输出

 <- v1 
'' '' ''  <- v2 
'a' 'd' 'v'  <- f1

在线代码：https ://wandbox.org/permlink/ZLbocXKdqYHT0zYi

于 2017-12-10T17:41:51.587 回答
0

看起来如果不修改构造函数是不可能的boost::container::flat。在不修改任何一个类的情况下，似乎只有 hack 可以做到这一点，例如使用reinterpret_cast. 我找到的解决方案是使用替代实现vector或非常丑陋的代码。

在进入我的解决方案之前，我必须说这可能是两个类的缺陷。这些类应该有一组 release()/aquire(start, end)函数，分别将指针范围返回给释放所有权的数据，并从那时起获取拥有它的指针范围。另一种方法是使用一个构造函数，该构造函数从具有数据成员函数的任何其他容器移动。

解决方案使用reinterpret_cast和不同的实现vector

原来reinterpret_casting from std::vectortoboost::container::flat_set是不可能的，因为布局不兼容。但是，可以将 reinterpret_cast 从boost::container::vector开箱boost::container::flat_set即用（那是因为它们有一个共同的实现）。

#include<cassert>
#include<boost/container/flat_set.hpp>

int main(){
    boost::container::vector<double> v = {1.,2.,3.};
    boost::container::flat_set<double> fs = std::move(reinterpret_cast<boost::container::flat_set<double>&>(v));

    assert(v.size() == 0);
    assert(*fs.find(2.) == 2.);s
    assert(fs.find(4.) == fs.end());
}

所以，我可以替换std::vector为boost::container::vector，我可以将数据移动到flat_set.

std::vector使用丑陋代码的非便携式解决方案

std::vector和的布局boost::container::vector不同的原因是boost::container::vector元数据以这种方式存储：

class boost::container::vector{
   pointer     m_start;
   size_type   m_size;
   size_type   m_capacity;
}

而std::vector（在 GCC 中）基本上是纯指针，

class std::vector{
    pointer _M_start;
    pointer _M_finish;
    pointer _M_end_of_storage;
}

所以，我的结论是，鉴于我使用的实现std::vector与boost::container::flat_set.

在极端情况下，可以这样做（对不起，如果这段代码冒犯了某人，代码不可移植）：

template<class T>
boost::container::flat_set<T> to_flat_set(std::vector<T>&& from){
//  struct dummy_vector{T* start; T* finish; T* end_storarge;}& 
//      dfrom = reinterpret_cast<dummy_vector&>(from);
    boost::container::flat_set<T> ret;
    struct dummy_flat_set{T* start; std::size_t size; std::size_t capacity;}& 
        dret = reinterpret_cast<dummy_flat_set&>(ret); 
    dret = {from.data(), from.size(), from.capacity()};
//  dfrom.start = dfrom.finish = dfrom.end_storarge = nullptr;
    new (&from) std::vector<T>();
    return ret;
};

int main(){
    std::vector<double> v = {1.,2.,3.};
    boost::container::flat_set<double> fs = to_flat_set(std::move(v));

    assert(v.size() == 0);
    assert(*fs.find(2.) == 2.);
    assert(fs.find(4.) == fs.end());
}

请注意，我根本没有考虑分配器问题。我不确定如何在这里处理分配器。

回想起来，我不介意cast对这个特定问题使用一种形式，因为我必须以某种方式告诉向量在移动到flat_set. （问题是这变得极端，因为它是一个reinterpret_cast。）但是这是一个次要问题，应该有合法的方式从 移动std::vector到boost::container::vector。

于 2017-12-11T08:34:51.433 回答