序列化初步之三（翻译）
http://www.codeproject.com/cpp/serialization_primer3.asp
在前两部分，我们学习了在通常情况下，如何为序列化提供有力的支持。在这一部分，我们将学习序列化任何一种对象时的特殊的规则。这里有四个常用的参考例子。每个例子都由前一个构成。
Ø 序列化一个简单类
Ø 序列化一个派生类
Ø 序列化一个同源的聚集类
Ø 序列化一个异源的聚集类
我们的Searialize()方法将返回以下状态码之一：
l Success
l InvalidFormat
l UnsupportedVersion
l ReadError
l WriteError
序列化一个简单类
一个“简单类”的定义是：一个即没有父类，也没有聚集类的对象。序列化一个简单的类需要以下步骤：
1. 序列化对象签名和版本
2. 序列化对象成员（如果有）
在下面的例子中，类Point包含两个int型变量，表示点的坐标。对象的签名和版本定义成静态成员（m_strSignature和m_nVersion），所以每个Point类的实例都共享它们。
int Point::serialize
(CArchive* pArchive)
{
ASSERT (pArchive != NULL);
// Step 1: Serialize signature and version
int nVersion;
try {
if (pArchive->IsStoring()) {
(*pArchive) << Point::m_strSignature;
(*pArchive) << Point::m_nVersion;
} else {
CString strSignature;
(*pArchive) >> strSignature;
if (strSignature != Point::m_strSignature)
return (Status::InvalidFormat);
(*pArchive) >> nVersion;
if (nVersion > Point::m_nVersion;)
return (Status::UnsupportedVersion);
}
// Step 2: Serialize members
if (pArchive->IsStoring()) {
(*pArchive) << m_nX;
(*pArchive) << m_nY;
} else {
(*pArchive) >> m_nX;
(*pArchive) >> m_nY;
}
}
catch (CException* pException) {
// A read/write error occured
pException->Delete();
if (pArchive->IsStoring())
return (Status::WriteError);
return (Status::ReadError);
}
// Object was successfully serialized
return (Status::Success);
}
序列化一个派生类
派生类是指派生于一个简单类，并且不是一个聚集类的类。序列化一个派生类需要以下步骤：
1. 序列化对象签名和版本
2. 序列化对象的基类<<额外的步骤
3. 序列化对象的成员（如果有）
在下面的例子中，类ColoredPoint从Point类派生，并且增加一个叫做m_nColor的int型变量，表示点的颜色。如同所有序列化的类一样，ColoredPoint类也定义一个静态签名和版本。
int ColoredPoint::serialize
(CArchive* pArchive)
{
ASSERT (pArchive != NULL);
// Step 1: Serialize signature and version
int nVersion;
try {
if (pArchive->IsStoring()) {
(*pArchive) << ColoredPoint::m_strSignature;
(*pArchive) << ColoredPoint::m_nVersion;
} else {
CString strSignature;
(*pArchive) >> strSignature;
if (strSignature != ColoredPoint::m_strSignature)
return (Status::InvalidFormat);
(*pArchive) >> nVersion;
if (nVersion > ColoredPoint::m_nVersion;)
return (Status::UnsupportedVersion);
}
// Step 2: Serialize the base class
int nStatus = Point::serialize (pArchive);
if (nStatus != Status::Success)
return (nStatus);
// Step 3: Serialize members
if (pArchive->IsStoring())
(*pArchive) << m_nColor;
else
(*pArchive) >> m_nColor;
}
catch (CException* pException) {
// A read/write error occured
pException->Delete();
if (pArchive->IsStoring())
return (Status::WriteError);
return (Status::ReadError);
}
// Object was successfully serialized
return (Status::Success);
}
序列化一个同源的聚集类
同源聚集类常常用来存储数量不定的多个同类型对象。序列化同源聚集类需要以下步骤：
1. 序列化对象签名和版本
2. 序列化对象的基类（如果有）
3. 序列化聚集对象的数量<<额外的步骤
4. 序列化每个聚集对象<<额外的步骤
5. 序列化对象的其它成员（如果有）
在下面的例子中，类ColoredPointList是一个ColoredPoint对象的聚集。为了简单，ColoredPointList类使用CPtrArray来存储对象。如同所有序列化类一样，ColoredPointList类也定义了一个静态签名和版本。以下是ColoredPointList类的示例：
class ColoredPointList
{
// Construction/destruction
public:
ColoredPointList::ColoredPointList();
virtual ColoredPointList::~ColoredPointList();
// Attributes
public:
static const CString m_strSignature;
static const int m_nVersion;
// Operations
public:
int serialize (CArchive* pArchive);
// Members
protected:
CPtrArray m_coloredPoints;
}
下面是我们如何序列化它：
int ColoredPointList::serialize
(CArchive* pArchive)
{
ASSERT (pArchive != NULL);
int nStatus = Status::Success;
// Step 1: Serialize signature and version
int nVersion;
try {
if (pArchive->IsStoring()) {
(*pArchive) << ColoredPointList::m_strSignature;
(*pArchive) << ColoredPointList::m_nVersion;
} else {
CString strSignature;
(*pArchive) >> strSignature;
if (strSignature != ColoredPointList::m_strSignature)
return (Status::InvalidFormat);
(*pArchive) >> nVersion;
if (nVersion > ColoredPointList::m_nVersion;)
return (Status::UnsupportedVersion);
}
// Step 2: Serialize base class (if any)
//
// Nothing to do since ColoredPointList isn't derived from anything.
// But if it was derived from BaseColoredPointList, we'd do:
//
// nStatus = BaseColoredPointList::serialize (pArchive);
// if (nStatus != Status::Success)
// return (nStatus);
// Step 3: Serialize number of items in collection
int nItems = 0;
if (pArchive->IsStoring())
(*pArchive) << m_coloredPoints.GetSize();
else
(*pArchive) >> nItems;
// Step 4: Serialize each object in collection
for (int nObject=0; (nObject < nItems); nObject++) {
// 4a: Point to object being serialized
ColoredPoint* pColoredPoint = NULL;
if (pArchive->IsStoring())
pColoredPoint = (ColoredPoint *) m_coloredPoints.GetAt (nObject);
else
pColoredPoint = new ColoredPoint();
ASSERT (pColoredPoint != NULL);
// 4b: Serialize it
nStatus = pColoredPoint->serialize (pArchive);
if (nStatus != Status::Success)
return (nStatus);
if (!pArchive->IsStoring())
m_coloredPoints.Add (pColoredPoint);
}
// Step 5: Serialize object's other members (if any)
//
// Nothing to do since ColoredPointList doesn't have any other
// members. But if it contained an int (m_nSomeInt) and a Foo
// object (m_foo), we'd do:
//
// if (pArchive->IsStoring())
// (*pArchive) << m_nSomeInt;
// else
// (*pArchive) >> m_nColor;
//
// nStatus = m_foo::serialize (pArchive);
// if (nStatus != Status::Success)
// return (nStatus);
}
catch (CException* pException) {
// A read/write error occured
pException->Delete();
if (pArchive->IsStoring())
return (Status::WriteError);
return (Status::ReadError);
}
// Object was successfully serialized
return (Status::Success);
}
序列化一个异源聚集类
异源聚集类常常用来存储数量不定的多个不同类型对象。序列化一个异源聚集类需要以下步骤：
1. 序列化对象签名和版本
2. 序列化对象的基类（如果有）
3. 序列化聚集对象的数量
4. 对于每一个聚集对象
a． 序列化对象签名<<额外的步骤
b．序列化对象
5. 序列化对象的其它成员（如果有）
你会注意到在序列化中一个仅有的额外步骤是4(a)，在序列化每个对象自身前，将先序列化每个对象的签名。这样以后读取数据就比较方便。当序列化一个同源聚集类时，我们处理同类型的对象（前一个例子中的ColoredPoint）。为了读取一个ColoredPoint类，我们在堆中构造它，并且调用它的Searialize()方法。
ColoredPoint* pColoredPoint = new ColoredPoint();
nStatus = pColoredPoint->serialize (pArchive);
当我们处理异源聚集类时，在序列化对象之前，我们需要知道我们读取的对象的类型。这个信息来自于对象的签名。由于我们在序列化对象时已经保存了对象的签名，因此读取时我们可以根据对象的类型构造合适的对象。
// Read object signature
CString strSignature;
pArchive >> strSignature;
// Construct object of appropriate type
ISerializable* pObject = NULL;
if (strSignature == ColoredPoint::m_strSignature)
pObject = new ColoredPoint();
else
if (strSignature == Line::m_strSignature)
pObject = new Line();
else
if (strSignature == Rectangle::m_strSignature)
pObject = new Rectangle();
else
return (Status::InvalidFormat);
ASSERT (pObject != NULL);
// Read it back in
nStatus = pObject->serialize (pArchive);
在上面的代码片段中，ColoredPoint，Line和Rectangle都是（最终）派生于一个公共的基类ISerializable。这个类除了纯虚函数外没有比一个抽象基类更多的内容（换句话说，是一个“接口” ）。ISerializable定义方法getSignature()，getVersion和Serialize()。
class ISerializable
{
// Construction/destruction
public:
ISerializable::ISerializable()
{ }
virtual ISerializable::~ISerializable()
{ }
// Operations
public:
// Get the object's signature
virtual CString getSignature() = 0;
// Get the object's version
virtual int getVersion() = 0;
// Serialize the object
virtual int serialize (CArchive* pArchive) = 0;
}
好，让我们序列化异源聚集类。在下面的例子中，类ShapeList是可变数量的ColoredPoint，Line和Rectangle对象的聚集，它们都派生于ISerializable。你可以将这些类看做是“ISerializable接口的实现”。
int ShapeList::serialize
(CArchive* pArchive)
{
ASSERT (pArchive != NULL);
int nStatus = Status::Success;
// Step 1: Serialize signature and version
int nVersion;
try {
if (pArchive->IsStoring()) {
(*pArchive) << ShapeList::m_strSignature;
(*pArchive) << ShapeList::m_nVersion;
} else {
CString strSignature;
(*pArchive) >> strSignature;
if (strSignature != ShapeList::m_strSignature)
return (Status::InvalidFormat);
(*pArchive) >> nVersion;
if (nVersion > ShapeList::m_nVersion;)
return (Status::UnsupportedVersion);
}
// Step 2: Serialize base class (if any)
//
// Nothing to do since ShapeList isn't derived from anything.
// But if it was derived from BaseShapeList, we'd do:
//
// nStatus = BaseShapeList::serialize (pArchive);
// if (nStatus != Status::Success)
// return (nStatus);
// Step 3: Serialize number of items in collection
int nItems = 0;
if (pArchive->IsStoring())
(*pArchive) << m_shapes.GetSize();
else
(*pArchive) >> nItems;
// Step 4: Serialize each object in collection
for (int nObject=0; (nObject < nItems); nObject++) {
// 4a: First serialize object's signature
CString strSignature;
if (pArchive->IsStoring())
(*pArchive) << pObject->getSignature();
else
(*pArchive) >> strSignature;
//
// 4b: Then serialize object
//
// 4b (1): Point to object being serialized
ISerializable* pObject = NULL;
if (pArchive->IsStoring())
pObject = (ISerializable *) m_shapes.GetAt (nObject);
else {
if (strSignature == ColoredPoint::m_strSignature)
pObject = new ColoredPoint();
else
if (strSignature == Line::m_strSignature)
pObject = new Line();
else
if (strSignature == Rectangle::m_strSignature)
pObject = new Rectangle();
else
return (Status::InvalidFormat);
}
ASSERT (pObject != NULL);
// 4b (2): Serialize it
nStatus = pObject->serialize (pArchive);
if (nStatus != Status::Success)
return (nStatus);
if (!pArchive->IsStoring())
m_shapes.Add (pColoredPoint);
}
// Step 5: Serialize object's other members (if any)
//
// Nothing to do since ShapeList doesn't have any other
// members. But if it contained an int (m_nSomeInt) and
// a Foo object (m_foo), we'd do:
//
// if (pArchive->IsStoring())
// (*pArchive) << m_nSomeInt;
// else
// (*pArchive) >> m_nColor;
//
// nStatus = m_foo::serialize (pArchive);
// if (nStatus != Status::Success)
// return (nStatus);
}
catch (CException* pException) {
// A read/write error occured
pException->Delete();
if (pArchive->IsStoring())
return (Status::WriteError);
return (Status::ReadError);
}
// Object was successfully serialized
return (Status::Success);
}
类工厂
你可以用一个基于签名的“类工厂”来提供一个新的对象实例以替换在代码片段中丑陋的if申明。这里有一些关于类工厂的参考文章：
Generic Class Factory by Robert A. T. Káldy
The Factory Method (Creational) Design Pattern by Gopalan Suresh Raj
Abstract Factory Pattern by Mark Grand
虽然文章是复杂多样的，但在这之后的基本思想是一样的。一个类工厂和类没有多大差别，它提供一个适当的指定的静态方法（例如：create()），这个方法提供一个特殊类型的对象。通过工厂的create()方法，你可以隐藏令人厌恶的if申明。稍微整理一下代码：
...
// Construct object of appropriate type
ISerializable* pObject = MyClassFactory::create (strSignature);
ASSERT (pObject != NULL);
...
