I was running some tests involving std::weak_ptr using boost serialization, and I realized that when I read a std::weak_ptr from an archive that doesn't contain the "parent" std::share_ptr, the behavior of the read pointer is "hard to understand".

Here is an example :

#include <cassert>

#include <sstream>
#include <memory>

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>

#include <boost/serialization/export.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/weak_ptr.hpp>

class MyInt
{
public:
    MyInt()
        : value(0)
    {
    }

    int value;

    template<class Archive>
    void serialize(Archive &ar, unsigned int)
    {
        ar & value;
    }
};

int main()
{
    std::stringstream data;

    {
        std::shared_ptr<MyInt> shared = std::make_shared<MyInt>();
        assert(shared.use_count() == 1);
        shared->value = 12;

        /* Write a weak_ptr */
        {
            std::weak_ptr<MyInt> weak(shared);
            assert(shared.use_count() == 1);

            boost::archive::binary_oarchive ar(data);

            ar << weak;
            assert(shared.use_count() == 1);
        }

        assert(shared.use_count() == 1);

        /* Read a weak_ptr */
        std::weak_ptr<MyInt> weak;
        {
            boost::archive::binary_iarchive ar(data);

            ar >> weak;

            assert(shared.use_count() == 1);
            assert(weak.use_count() == 1);

            {
                std::shared_ptr<MyInt> loaded = weak.lock();
                assert(loaded);

                /* It looks good */
                assert(loaded->value == 12);

                /* Let's see... */
                assert(loaded != shared);
                shared->value = 42;
                assert(loaded->value == 12);

                /* So another shared_ptr exists somewhere... */
                assert(shared.use_count() == 1);
                assert(loaded.use_count() == 2);
                assert(weak.use_count() == 2);
            }

            /* But where ? */
            assert(shared.use_count() == 1);
            assert(weak.use_count() == 1);
        }

        /* Let's see */
        assert(shared.use_count() == 1);
        assert(weak.use_count() == 0 /* weak.expired() */);

        /* Hmm, was it inside the archive itself ? */
    }

    /* Let's try again, we need the input stream to be back to the beginning */
    data.seekg(0);

    std::weak_ptr<MyInt> weak;
    {
        boost::archive::binary_iarchive ar(data);

        assert(weak.use_count() == 0);

        ar >> weak;

        assert(weak.use_count() == 1);

        /* It looks fine */
    }

    assert(weak.use_count() == 0);

    /* aw, on a second thought, it really doesn't */

    return 0;
}

I am building and running this using g++-9.3.0 with boost-1.72.0-1.

Clearly, the weak_ptr gets itself a shared_ptr "somewhere" as it can be used after being read. I was wondering "where it is stored and how to access it, if possible, without some `weak.lock()` call ?"

It looks like the shared_ptr gets destroyed at the same time as the archive, so I guess it is cleaned up thanks to the delete_created_pointers method when the iarchive is destroyed : does delete_created_pointers actually contains also shared_ptr ? As far as I can see in the code serialization/weak_ptr.hpp, we actually save then load a std::shared_ptr, so I was expecting the weak_ptr to expire as soon as the call returns : since it is not, there *is* another reference.

Now, I know I must save the shared_ptr in the archive myself to have my own reference and to get all weak_ptr running properly. But I came across this use case and I can't take it out of my mind, so if you have an explanation, I'm all ears.

Thank you