serialize不是std :: unique_ptr的成員

Question

這個問題更適合Boost論壇嗎？ 下面引用了完整的代碼，與該站點上的其他unique_ptr示例相比，我認為我沒有錯誤地嘗試將auto_ptr序列化示例轉換為unique_ptr示例。 因此，為什么我會在Boost庫的深處收到編譯錯誤？ 我以前在標准容器上使用Boost序列化沒有問題，盡管這是一個自定義適配器，但是如果已經編譯了類似的示例，為什么不這樣做呢？

我引用了http://www.boost.org/doc/libs/1_51_0/libs/serialization/example/demo_auto_ptr.cpp ，試圖使用自定義適配器對我的二叉樹進行序列化。 下面是代表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

上面的代碼與對樹成員函數的任何用法一樣進行編譯。 選擇調用保存后，即會出現編譯器錯誤。 這是主要的：

#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;
}

該編譯器錯誤如何：

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

感謝您幫助我解決此編譯器錯誤。

Answer 1

是您的序列化和加載功能的簽名不正確。 兩個參數的std::unique_ptr<T>參數都必須是非常量的。 由於它不能推斷類型（由於const），因此它只是忽略了重載而根本找不到它。