我有一个正在使用的简单系统,涉及序列化用户对象。我有一系列专门的模板类,它们作用于每种类型的读/写方式不同:

template<class T>
class ItemSerializer;

template<>
class ItemSerializer<int>
{
public:
    static void store( int const& obj )
    {
    }

    static void fetch( int& obj )
    {
    }
};

template<>
class ItemSerializer<NoteNumberArray>
{
public:
    static void store( NoteNumberArray const& obj )
    {
       // NoteNumberArray::_blocks is used here.
    }

    static void fetch( NoteNumberArray& obj )
    {
       // NoteNumberArray::_blocks is used here.
    }
};

根据类型的不同,它可能带有状态,也可能不带有状态,这对于将其分配给它的串行器类是必需的。在此示例中,我有两种类型的序列化器:intNoteNumberArray。对于int类型,store / fetch函数不需要任何其他状态,读/写实现非常简单。

但是,对于NoteNumberArray,状态是必需的,因此我创建了自己的类,而不是使用核心类型或STL类型。仅出于优化目的,此状态仅由ItemSerializer的实现使用。此私有(private)状态将用于优化读取/写入方法的速度和效率。由于序列化程序类不是有状态的,因此我将该状态放入用户对象。

我可能可以让ItemSerializer成为NoteNumberArray的 friend ,但这会导致循环依赖,并使ItemSerializer可以访问比可能需要的更多NoteNumberArray

这样的系统有什么好的设计?只是寻找一些技巧来帮助我入门。这是此示例的其他一些相关片段:
class Block
{
};

class NoteNumberArray
{
public:
    // Public interface, none of which will use _blocks. Only ItemSerializer uses _blocks.

private:
    std::vector<int> _array; // This should not be used directly by anyone, including ItemSerializer.
    std::vector<Block> _blocks; // This is the private state only used by ItemSerializer
};

最佳答案

我没有看到循环依赖性问题,没有依赖性问题使ItemSerializer<NoteNumberArray>成为NoteNumberArray的 friend 。

如果您不希望ItemSerializer<NoteNumberArray>能够看到NoteNumberArray的其他私有(private)部分,我确实会看到访问问题。

一种可能性是将_blocks包装到另一个类NoteNumberArraySerializerHelper中,该类将ItemSerializer<NoteNumberArray>作为 friend ,并且所有方法(包括构造函数和通常由编译器为您编写的其他内容)都是私有(private)的。然后,您必须将_blocks的公共(public)访问器/更改器方法提供给NoteNumberArray,但是除了ItemSerializer<NoteNumberArray>之外,没有人可以使用这些方法执行任何操作。

10-05 18:58