serialize不是std :: unique_ptr的成员

Question

Is this question more appropriate for Boost forums? The complete code is referenced below and I do not consider that I have incorrectly attempted to convert an auto_ptr serialization example into a unique_ptr example as compared to other unique_ptr examples on this site. Thus, why would I receive a compilation error deep within a Boost library? I have used Boost serialization on standard containers before with no problems and, although this is a custom adapter, if similar examples have compiled, why not this?

I referenced http://www.boost.org/doc/libs/1_51_0/libs/serialization/example/demo_auto_ptr.cpp in an attempt to serialize my binary tree using a custom adaptor. Below is a code dump representing an sscce.

// disables conversion from 'std::streamsize' to 'size_t', possible loss of data
#pragma warning(disable:4244)  

#ifndef BINARY_SEARCH_TREE_H_
#define BINARY_SEARCH_TREE_H_

#include<functional>

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

#define BST_FILE_NAME "tree.dat"    // default filename used to save and load

namespace boost { 

    namespace serialization {

        template <class Archive, class T>
        inline void save
            (Archive &archive, 
            const std::unique_ptr<T> &subtree,  
            const unsigned int file_version)
        {
            // only the raw pointer has to be saved
            const T *const  subtree_x = subtree.get();

            archive << subtree_x;
        }

        template <class Archive, class T>
        inline void load
            (Archive &archive, 
            const std::unique_ptr<T> &subtree, 
            const unsigned int file_version)
        {

            T *p_subtree;

            archive >> p_subtree;

            #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
                subtree.release();
                subtree = std::unique_ptr< T >(p_subtree);
            #else
                subtree.reset(p_subtree);
            #endif
        }

        template <class Archive, class T>
        inline void serialize
            (Archive &archive, 
            const std::unique_ptr<T> &subtree, 
            const unsigned int file_version)
        {
            boost::serialization::split_free(archive, subtree, file_version);
        }

    } // namespace serialization
} // namespace boost


template <class T = int>
class BinarySearchTree{

    class BinarySearchTreeNode{
    public:

        std::unique_ptr<BinarySearchTreeNode> node_factory(const T &new_key, const T    &new_index){
            return std::unique_ptr<BinarySearchTreeNode>(new    BinarySearchTreeNode(new_key, new_index)); }

        BinarySearchTreeNode(BinarySearchTreeNode &&other) : key(other.key), index(other.index), left(std::move(other.left)), 
            right(std::move(other.right)) {key = index = left = right = nullptr; }

        BinarySearchTreeNode &operator=(BinarySearchTreeNode &&rhs) { if(this != rhs) { key = rhs.key; index = rhs.index; 
            left = std::move(rhs.left); right = std::move(rhs.right); 
            rhs.key = rhs.index = rhs.left = rhs.right = nullptr;} return *this;}

        ~BinarySearchTreeNode() {}  // Note to self; don't hide the destructor

        friend class BinarySearchTree;

    private:

        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive &archive, const unsigned int /* file_version */){
            archive & key;
            archive & index;
            archive & left;
            archive & right;
        }

        T key;
        long index;

        std::unique_ptr<BinarySearchTreeNode> left;
        std::unique_ptr<BinarySearchTreeNode> right;

        BinarySearchTreeNode() {}
        BinarySearchTreeNode(const T &new_key, const T &new_index) :key(new_key), index(new_index), 
                                    left(nullptr), right(nullptr) {}

    };

    std::unique_ptr<BinarySearchTreeNode> root;

    std::list<T> tree_keys;
    std::list<long> tree_indicies;



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



    BinarySearchTree(const BinarySearchTree &other){}
    BinarySearchTree &operator=(const BinarySearchTree &rhs){}

    std::unique_ptr<BinarySearchTreeNode> insert(const T &new_key, const T &new_index, 
                std::unique_ptr<BinarySearchTreeNode> &tree){
        if(tree == nullptr){
            return root->node_factory(new_key, new_index);
        }else if(std::less<T> () (new_key, tree->key)){ // Left insertion
            tree->left = insert(new_key, new_index, tree->left);
            return std::move(tree);
        }else {   // Right insertion
            tree->right = insert(new_key, new_index, tree->right);
            return std::move(tree);
        }
    }

public:
    BinarySearchTree() : root(nullptr) {}
    BinarySearchTree(BinarySearchTree &&other) : root(std::move(other.root)) { other.root = nullptr; }
    BinarySearchTree &operator=(BinarySearchTree &&rhs) { if(this != rhs) { root = std::move(rhs.root); 
        rhs.root = nullptr} return *this; }
    bool insert_into_tree(const T &new_key, const T &new_index){
        if(new_key == NULL){
            return false;
        }
        root = std::move(insert(new_key, new_index, root));
        return true;
    }


    void save(const BinarySearchTree &tree)
    {
        // create and open a binary archive for output
        std::ofstream writer(BST_FILE_NAME, std::ofstream::out | std::ofstream::binary);

        if(writer){
            boost::archive::binary_oarchive serial_writer(writer);
            //set_flags(0, true);
            // write class instance to archive
            serial_writer << tree;
            // archive and stream closed when destructors are called

        }else if(writer.fail()){
            writer.clear();
        }
    }

    void load(BinarySearchTree &tree)
    {
        // create and open a binary archive for output
        std::ifstream reader(BST_FILE_NAME, std::ifstream::in | std::ifstream::binary);

        if(reader){
            boost::archive::binary_iarchive serial_reader(reader);
            // read class state from archive
            serial_reader >> tree;
            // archive and stream closed when destructors are called

        }else if(reader.fail()){
            reader.clear();
        }
    }
    ~BinarySearchTree() {}
};

#endif

The code above compiles as does any usage of the tree member functions. Once choosing to call save, that is when the compiler error appears. Here is main:

#include<cstdlib>

#include "physical_view.h"

using namespace std;

int main(int argc, char *argv[]){


    BinarySearchTree<> tree;

    tree.insert_into_tree(10, 5);
    tree.insert_into_tree(5, 15);
    tree.insert_into_tree(15, 10); <--------- All is wonderful to here!

    tree.save(tree); <---------- Compiler unhappy here!

    return EXIT_SUCCESS;
}

How about that compiler error:

Error   1   error C2039: 'serialize' : is not a member of 'std::unique_ptr<_Ty>'    c:\boost_12\include\boost-1_53_1\boost\serialization\access.hpp 118

I thank you for helping me resolve this compiler error.

Answer 1

The is that the signature of your serialize and load functions is incorrect. The std::unique_ptr<T> argument needs to be non-const for both of them. Since it can't deduce the types (due to the const), it simply ignores the overload and fails to find it at all.