Question

In the code below I try to write two objects to a file with no extension. The problem occurs initially at the writing stage because nothing actually gets written to the file. Then the second part; the reading stage, causes an exception when the file is opened with the line:

boost::archive::text_iarchive ia(ifs);

I took this from boost example 1. I also tried following the 3rd answer for this problem on this page Boost Serialization multiple objects

    #include <fstream>

// include headers that implement a archive in simple text format
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
/////////////////////////////////////////////////////////////
// gps coordinate
//
// illustrates serialization for a simple type
//
class gps_position
{
    private:
        friend class boost::serialization::access;
    // When the class Archive corresponds to an output archive, the
    // & operator is defined similar to <<.  Likewise, when the class Archive
    // is a type of input archive the & operator is defined similar to >>.
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & degrees;
            ar & minutes;
            ar & seconds;
        }
        int degrees;
        int minutes;
        float seconds;
    public:
        gps_position(){};
        gps_position(int d, int m, float s) :
        degrees(d), minutes(m), seconds(s)
    {}
};
int main()
{
    // create and open a character archive for output
    std::ofstream ofs("filename",std::ios::app);

    // create class instance

    gps_position g0(35, 59, 24.567f);
    gps_position g1(35, 59, 88.567f);
    // save data to archive
    //{
        boost::archive::text_oarchive oa(ofs);
        // write class instance to archive
        size_t number_of_objects = 2;
        oa << number_of_objects;
        oa << g0;
        oa << g1;
        // archive and stream closed when destructors are called
   // }

    // ... some time later restore the class instance to its orginal state

    gps_position newg0;
    gps_position newg1;
   // {
        // create and open an archive for input
        std::ifstream ifs("filename");
        boost::archive::text_iarchive ia(ifs);
        // read class state from archive


        ia >> number_of_objects;
        ia >> newg0;
        ia >> newg1;
        // archive and stream closed when destructors are called
    //}

    return 0;
}

Answer 1

Uncomment the braces surrounding the writing stage; otherwise neither the archive nor the std::ofstream are closed before trying to read.

As mentioned by several people in the comments, the stream needs to be flushed and closed, which is done automatically when destructing your instance of std::ofstream; in that case when encountering the closing brace of the writing stage.