C++ 如何隔离派生类的数据（序列化）？

我从以下代码开始：

#include <iostream>

class Base
{
private:
    char a[4];
public:
    Base(void){memcpy(a, "Base", 4);}
    ~Base(void){}
};

class Derived :
    public Base
{
private:
    char b[8];
public:
    Derived(void){ memcpy(b, "Derived", 8);}
    ~Derived(void){}
};

#包括
阶级基础
{
私人：
chara[4]；
公众：
基（空）{memcpy（a，“基”，4）；}
~Base（void）{}
};
派生类：
公共基地
{
私人：
charb[8]；
公众：
派生（void）{memcpy（b，“派生”，8）；}
~Derived（void）{}
};

要提取基类的数据，我将执行以下操作：

int main(void)
{
    Derived derived;

    char* onlyBase = new char[sizeof(Base) + 1];//+1 for '\0'
    memcpy(onlyBase, &static_cast<Base>(derived), sizeof(Base));
    onlyBase[sizeof(Base)] = '\0';

    std::cout << onlyBase;
}

int main（无效）
{
派生的；
char*onlyBase=new char[sizeof（Base）+1]；///+1表示“\0”
memcpy（仅基础和静态_转换（派生）、sizeof（基础））；
只有基[sizeof（Base）]='\0'；
std：：cout它是一种黑客行为，它可能适用于您的情况：

char* onlyDerived = new char[sizeof(Derived) - sizeof(Base) + 1];//+1 for '\0'
memcpy(onlyDerived, &reinterpret_cast<const char*>(&derived) + sizeof(Base), sizeof(Derived) - sizeof(Base));
onlyDerived[sizeof(Derived) - sizeof(Base)] = '\0';

char*onlydrived=new char[sizeof（派生）-sizeof（基本）+1]；//+1表示“\0”
memcpy（仅驱动、重新解释和转换（派生）+sizeof（基本）、sizeof（派生）-sizeof（基本））；
仅驱动[sizeof（派生）-sizeof（基础）]='\0'；

我不鼓励你做这样的事情，你可能有几个问题（不可移植…，对齐，填充，末端…）

你可以这样做：
char*Base:：serialize（）const；
。
你为什么要写这么麻烦和毫无意义的东西呢？当然
sizeof（static_cast（derived））+1
只是
sizeof（Base）+1
，而不是
memcpy
，你可以只写
：a{'b'，a'，s'，e}
。你不需要
（无效）
，只要
（）
就可以了。好吧，是的。我会编辑它。
（无效）
是由我的IDE创建的，
memcpy
更容易编辑，因为我不需要将字符串拆分为单个字符。或者创建a和b实际以空结尾的字符串？目前它们甚至不是“C”字符串。请告诉我们这只是一个奇怪的实验。一般来说，您无法知道
b和
Base
的存储被打包在
派生的
的实例中。标准没有规定这一点。如果
Dervied
有两个或两个以上的成员，那么
Base
的存储理论上可以放在它们之间（实际上不太可能）。因此“只有类的派生部分的数据”在很大程度上是没有意义的。