修改代码去除Boost命名空间，类内用序列化函数报错求助

Got it, let's work through this issue step by step. The problem you're hitting is that Boost Serialization expects its save/load functions to be discoverable either in the boost::serialization namespace, or via member functions/ADL (Argument-Dependent Lookup) when tied to your class. Here are two solid solutions to move those functions into your class and ditch the Boost namespace wrapper:

Solution 1: Use Class Member Functions #

The cleanest approach is to turn save and load into private member functions of your class, then grant access to Boost's serialization framework via a friend declaration. This way, you don't need to wrap anything in boost::serialization.

class my_class {
private:
    // Let Boost's serialization framework access our private methods
    friend class boost::serialization::access;

    // Save function as a const member (since we're reading from a const object)
    template<class Archive>
    void save(Archive& ar, const unsigned int version) const {
        // Your existing save logic goes here—use class members directly
        ar & this->some_member;
        ar & this->another_member;
    }

    // Load function (non-const, since we're modifying the object)
    template<class Archive>
    void load(Archive& ar, const unsigned int version) {
        // Your existing load logic here
        ar & this->some_member;
        ar & this->another_member;
    }

    // Critical macro to tell Boost to use separate save/load instead of a single serialize function
    BOOST_SERIALIZATION_SPLIT_MEMBER()

    // Your class's data members
    int some_member;
    std::string another_member;
};

Why this works: #

• The boost::serialization::access friend lets the framework call your private save/load methods.
• The BOOST_SERIALIZATION_SPLIT_MEMBER() macro registers the split functions with Boost, so it knows not to look for a single serialize method.

Solution 2: Use Friend Free Functions (Inside the Class) #

If you prefer to keep save/load as free functions but avoid the Boost namespace, declare them as friends inside your class. This leverages ADL so Boost can find them without needing the boost::serialization wrapper.

class my_class {
private:
    int some_member;
    std::string another_member;

    // Declare save/load as friend functions inside the class
    template<class Archive>
    friend void save(Archive& ar, const my_class& t, unsigned int version) {
        ar & t.some_member;
        ar & t.another_member;
    }

    template<class Archive>
    friend void load(Archive& ar, my_class& t, unsigned int version) {
        ar & t.some_member;
        ar & t.another_member;
    }

    // Macro to register split free functions for your class
    BOOST_SERIALIZATION_SPLIT_FREE(my_class)
};

Why this works: #

• By declaring the functions as friends inside my_class, they're associated with your class's namespace, so ADL will find them when Boost tries to serialize an instance of my_class.
• The BOOST_SERIALIZATION_SPLIT_FREE(my_class) macro tells Boost to use these split functions instead of a default serialize method.

Common Pitfalls to Avoid #

• Forgetting the friend declaration: Boost can't access private members or methods without it, which will cause compile errors.
• Missing the split macro: Without BOOST_SERIALIZATION_SPLIT_MEMBER() or BOOST_SERIALIZATION_SPLIT_FREE(), Boost will look for a single serialize function instead of your split save/load.
• Incorrect function signatures: Make sure save is const (since it takes a const my_class& when using free functions, or is a const member), and all parameters match the required template/type structure.

内容的提问来源于stack exchange，提问作者mikamul