Boost serialization - input stream error

[Hanske]

I am trying to load serialized content and I have been unable to solve the issue. I have boiled it down to a specific line of code. I tried to minimize the code as best as possible but also show some debugging. The class `loadAudi` is only there to show exactly where the mistake is. The line `ar& audi` in `loadAudi` is what is causing the error. Here is the code (complete output is at the bottom):

#include <armadillo>

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/void_cast_fwd.hpp>
#include <boost/serialization/binary_object.hpp>

#include <iostream>
#include <fstream>
#include <memory>
#include <sstream>
#include <vector>

class Engine
{
  public:
    Engine () {}
    Engine (const int cyl) : _cyl ( cyl ) {}
    int getCyl () const { return _cyl; }

  private:
    int _cyl;

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version) {
      ar & _cyl;
    }
};

class Car {
public:
    virtual char const* type() const = 0;
    virtual void printMember () const = 0;
    virtual void save (const std::string file) const { std::cout << "file" << std::endl; };

    virtual ~Car() = default;

private:
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version) {};
};

class Audi : public Car, public std::enable_shared_from_this<Car> {
public:

  Audi() {};
  Audi(const std::string owner, const int hp,const unsigned int cyl)
    : _owner ( owner ),
      _hp    ( hp ),
      _eng          ( std::make_shared<Engine>(cyl) )
  { }

  char const* type() const override { return "Audi"; }

  void printMember () const override
  {
    std::cout
      << this->type() << ":\n"
      << "owner: " << _owner
      << " hp: " << _hp
      << " engine: " << _eng->getCyl()
      << std::endl;
  }
  void save (const std::string file) const {
    std::ofstream of(file, std::ofstream::binary);
    std::stringstream strs;
    boost::archive::binary_oarchive ar(of);
    std::shared_ptr<const Car> audi = shared_from_this();
    boost::serialization::make_binary_object(&audi, sizeof(audi));
  }

private:
  std::string  _owner;
  int          _hp;
  std::shared_ptr<Engine> _eng;

  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version) {
      ar & boost::serialization::base_object<Car>(*this);
      ar & _owner;
      ar & _hp;
      ar & _eng;
  }
};

Audi& loadAudi (const std::string file_name) {
  std::cout << "Loading " << file_name << std::endl;
  std::ifstream in_f(file_name, std::ifstream::binary);

  std::cout << "1" << std::endl;
  std::shared_ptr<Car> audi; //= std::make_unique<Audi>();

  std::cout << "2" << std::endl;
  boost::archive::binary_iarchive ar(in_f);

  std::cout << "3" << std::endl;
  ar& audi;

  std::cout << "4" << std::endl;
  return dynamic_cast<Audi &>(*audi);
};

BOOST_CLASS_EXPORT(Audi);
BOOST_CLASS_EXPORT(Engine);
BOOST_SERIALIZATION_ASSUME_ABSTRACT(Car); //Tell Boost that Car is abstract

int main() {
  std::string save_file = "test.dat";
  std::ofstream of(save_file, std::ofstream::binary);
  std::ifstream in_f(save_file, std::ifstream::binary);
  {
    std::shared_ptr<Car> audi = std::make_shared<Audi>("Wilma", 3, 16);
    audi->printMember();

    std::stringstream strs;
    boost::archive::binary_oarchive ar(of);
    ar& audi;

    // audi_save_dir = strs.str();
    std::cout << "Count of audi:" << audi.use_count() << std::endl;

    ar << boost::serialization::make_binary_object(&audi, sizeof(audi));
  }


   {
     std::shared_ptr<Car> audi; //= std::make_unique<Audi>();
     std::cout << "Deserialize: Count of audi:" << audi.use_count() << std::endl;

     //std::stringstream strs(f);
     boost::archive::binary_iarchive ar(in_f);
     ar& audi;
     Audi& d = dynamic_cast<Audi &>(*audi);

     std::cout << "Deserialize: Count of audi:" << audi.use_count() << std::endl;
     std::cout << "Print Audi:" << std::endl;
     d.printMember();
   }


  std::shared_ptr<Car> audi = std::make_shared<Audi>("Daniel", 200, 8);
  audi->printMember();

  std::string test_dat = "my-new-audi.dat";
  audi->save(test_dat);
  Audi& d =  loadAudi(test_dat);
  d.printMember();

  return 0;
}

And the output:

 
Audi:
owner: Wilma hp: 3 engine: 16
Count of audi:1
Deserialize: Count of audi:0
Deserialize: Count of audi:2
Print Audi:
Audi:
owner: Wilma hp: 3 engine: 16
Audi:
owner: Daniel hp: 200 engine: 8
Loading my-new-audi.dat
1
2
3
terminate called after throwing an instance of 'boost::archive::archive_exception'
  what():  input stream error
[2]    29888 abort      ./a.out

I would appreciate any help!

[coder777]

Oon line 100 you have local shared_ptr to audi. As soon as loadAudi(...) ends the shared_ptr is destroyed (because it is actually not shared) and hence the result is invalid.

Why not return the shared_ptr?

[Hanske]

Hi coder777, thanks for the response. The `loadAudi()` class is just for debugging purposes i.e. to show that the issue comes exactly when `ar& audi` is called at line 141. When removing `loadAudi()` from the code, the results are the same but in this case the `ar& audi` at line 141 is the problem.

[Hanske]

Hi coder777, I'm not seeing how that can work with shared_ptr. I tried it but I don't think it is valid. What exactly did you have in mind?

[Hanske]

I got it to work. I needed to:

1. `Audi& loadAudi (const std::string file_name)` to `Audi loadAudi (const std::string file_name)`
2. Add `ar& audi` to `save()`

[coder777]

What I mean is this:

std::shared_ptr<Audi> loadAudi (const std::string file_name) {
  std::cout << "Loading " << file_name << std::endl;
  std::ifstream in_f(file_name, std::ifstream::binary);

  std::cout << "1" << std::endl;
  std::shared_ptr<Audi> audi;

  std::cout << "2" << std::endl;
  boost::archive::binary_iarchive ar(in_f);

  std::cout << "3" << std::endl;
  ar& audi;

  std::cout << "4" << std::endl;
  return audi;
};

The boost::archive: throws an exception when it cannot read the required object. The cause might be that it is not correctly written. Line 77 doen't look right.
You should use a try{...} catch block.

Avoid dynamic_cast unless you really need it. On line 142 you surley don't need i. Line 146 should be:

audi->printMember();

By the way: use_count() on line 129/137/144 is a member of shared_ptr. It tells how many times it is referenced. See:

http://www.cplusplus.com/reference/memory/shared_ptr/use_count/

What are you trying to do at this lines?

[Hanske]

Thanks for the help. I have a few comments:

1. Yes I deleted all `make_binary_object` lines as those are not needed.

2. If I change the code like in your post with (std::shared_ptr<Audi> audi; loadAudi()`) , what do I have to put then for line 155 and 156?

3. `use_count` was just for debugging purposes. I will delete it when everything works.

4. Yes you are correct. I don't need line 142.

Thanks in advance!

[coder777]

If I change the code like in your post with (std::shared_ptr<Audi> audi; loadAudi()`) , what do I have to put then for line 155 and 156?

shared_ptr is an replacement for raw pointers. Hence you can use them similarly:

  std::shared_ptr<Audi> d =  loadAudi(test_dat);
  if(d) // Checks whether loading the car was successful 
    d->printMember();
  else
    std::cout << "loadAudi failed\n"; 

What are line 77/131 good for? Can't you just remove them?

3. `use_count` was just for debugging purposes. I will delete it when everything works.

They just don't provide much useful information, do they?

[Hanske]

2. I tried that before and I get the same error as before. With the loadAudi() function changed to how you have it, I get:

Loading my-new-audi.dat
1
2
3
terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc
[1]    32062 abort      ./a.out

So the error here is at `ar& audi`. I also added `ar& audi` to `save`. If I but change the `loadAudi` function to:

Audi& loadAudi (const std::string file_name) to Audi loadAudi (const std::string file_name)

and add `ar& audi` to `save()` the code works. But I would like to know how your way would work.


1. Yes I just deleted them and everything compiled as usual. That was from testing things out.

[coder777]

Honestly i'm not sure what the problem is?

If I but change the `loadAudi` function to:

Of course. In the first case you are returning a reference to a local variable. See:

https://stackoverflow.com/questions/4643713/c-returning-reference-to-local-variable

The shared_ptr will not change that since it is as well a local (and not otherwise referenced) variable that is destroyed at the end of the function.

When you use loadAudi like this

Audi loadAudi (const std::string file_name)

you are returning a copy of the local variable which is okay. The shared_ptr has no effect here.

Since you don't use the special traits of shared_ptr (sharing the data) the question is: why do you use it in the first place?