在两个不同的连续容器之间移动

Question

我有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()的容器的移动构造函数，其中指针从参数中被盗。

Answer 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

Answer 2

看起来如果不修改构造函数boost::container::flat就不可能。 不修改任何一个类似乎只有一个黑客会这样做，例如使用reinterpret_cast。 我找到的解决方案要么使用vector的替代实现，要么使用非常难看的代码。

  

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

使用reinterpret_cast和vector

的不同实现的解决方案

事实证明reinterpret_cast从std::vector到boost::container::flat_set是不可能的，因为布局不兼容。 但是，可以从开箱即用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。