对具有不可复制值的stl容器使用boost序列化时出现编译错误

Question

If I have a non-copyable class and use this class as a value type of a stl container that I wanted to serialize it using boost serialize I get a compile error which indicates that I had wanted to use a deleted function. A simple code that causes the error is like this:

#include <boost/serialization/split_member.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/string.hpp>

#include <fstream>
#include <iostream>
#include <unordered_map>

using namespace std;

class Foo
{                                                                                                                                                                                
public:
  string s;

  Foo()
  {}

  Foo(string s):
    s(s)
  {}


  Foo(const Foo& other) = delete;
  Foo &operator=(const Foo &other) = delete;

  Foo(Foo &&other) noexcept = default;
  Foo &operator=(Foo &&other) noexcept = default;



  template <typename Archive>
  void save(Archive &ar, const unsigned int version) const
  {
    ar & this->s;
  }

  template <typename Archive>
  void load(Archive &ar, const unsigned int version)
  {
    ar & this->s;
  }

  BOOST_SERIALIZATION_SPLIT_MEMBER()

  friend class boost::serialization::access;
};

int main(int argc, char *argv[])
{
  vector<pair<const uint8_t, Foo>> bar;

  const char* text_file_name = "/tmp/test-fixed-multibit.txt";
  {
    std::ofstream ofs(text_file_name);
    boost::archive::text_oarchive ar(ofs);
    ar & bar;
  }

  {
    vector<pair<const uint8_t, Foo>> bar1;

    std::ifstream ifs(text_file_name);
    boost::archive::text_iarchive ar(ifs);

    ar & bar1;
  }
  return 0;
}

Which it gives me an error like this:

/usr/include/c++/4.8/bits/stl_construct.h:75:7: error: use of deleted function ‘constexpr std::pair<_T1, _T2>::pair(std::pair<_T1, _T2>&&) [with _T1 = const unsigned char; _T2 = Foo]’
     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
       ^
In file included from /usr/include/c++/4.8/bits/stl_algobase.h:64:0,
                 from /usr/include/c++/4.8/vector:60,
                 from /usr/local/include/boost/serialization/vector.hpp:20,
                 from foo.cc:3:
/usr/include/c++/4.8/bits/stl_pair.h:128:17: note: ‘constexpr std::pair<_T1, _T2>::pair(std::pair<_T1, _T2>&&) [with _T1 = const unsigned char; _T2 = Foo]’ is implicitly deleted because the default definition would be ill-formed:
       constexpr pair(pair&&) = default;
                 ^
/usr/include/c++/4.8/bits/stl_pair.h:128:17: error: use of deleted function ‘Foo::Foo(const Foo&)’
foo.cc:28:3: error: declared here
   Foo(const Foo& other) = delete;

I deleted some parts of the error, but they were like lines we have copied here. You can check the correctness of the code by replacing Foo with another type like string .

Do I have a mistake about using boost or is this a misbehavior of boost serialize?

I used c++11 with g++-4.8 and my boost version is 1-60.0 compiled from source.

Edit:

As @sehe stated in his answer using g++-5.x can solve the compile error. But it is true just for std::vector and using other containers like std::unordered_map causes the same compile error even with g++-5.x.

Answer 1

The problems seems to be that std::string is not noexcept move-assignable:

  // PR 58265, this should be noexcept.
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2063. Contradictory requirements for string move assignment

(that's from line 584 in my basic_string.h)

Indeed replacing std::string with int make everything work fine:

Live On Coliru

#include <boost/serialization/split_member.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/string.hpp>

#include <fstream>
#include <iostream>
#include <unordered_map>

struct Foo {
    int s;

    Foo(int s = {}) : s(s) {}

    Foo(const Foo &other) = delete;
    Foo &operator=(const Foo &other) = delete;

    Foo(Foo &&other) noexcept = default;
    Foo &operator=(Foo &&other) noexcept = default;

    template <typename Archive> void save(Archive &ar, const unsigned int version) const { ar & this->s; }

    template <typename Archive> void load(Archive &ar, const unsigned int version) { ar & this->s; }

    BOOST_SERIALIZATION_SPLIT_MEMBER()

    friend class boost::serialization::access;
};

int main(int argc, char *argv[]) {
    std::vector<std::pair<const uint8_t, Foo> > bar;

    const char *text_file_name = "test-fixed-multibit.txt";
    {
        std::ofstream ofs(text_file_name);
        boost::archive::text_oarchive ar(ofs);
        ar & bar;
    }

    {
        std::vector<std::pair<const uint8_t, Foo> > bar1;

        std::ifstream ifs(text_file_name);
        boost::archive::text_iarchive ar(ifs);

        ar & bar1;
    }
}

Answer 2

It seems a bug in boost code, I reported this in boost bug tracker. But for a fast solution you could change one line in file boost/serialization/archive_input_unordered_map.hpp line 43 ( s.insert(t.reference()); ) must be replaced with:

  s.emplace(std::piecewise_construct,
            std::forward_as_tuple(std::move(t.reference().first)),
            std::forward_as_tuple(std::move(t.reference().second)));

This is for boost-1.60 and you must find the line in other versions, and it just corrects unordered_map insertion. May be general solution possible for that but currently this patch solved my problem.

Update:

As in the bug have reported, this bug has fixed in boost-1.61.