C++ 如何在创建后正确填充对象而不修改类声明？

我想知道是否有一种方法可以在实例化后填充对象。假设从类Foo实例化的对象具有以下实现：

class Foo
{
    size_t addr;
    unsigned allocationNum;

public:
    Foo()
    {
        addr = (size_t)this;
        allocationNum = 0;
    }

    ~Foo()
    {
        addr = 0;
        allocationNum = 0;
    }

    void SetAllocNum(unsigned nAllocationNum)
    {
         allocationNum = nAllocationNum;
    }

    unsigned GetAllocNum() const
    {
        return allocationNum;
    }

    size_t GetAddress() const
    {
        return addr;
    }
};

然后通过

Foo*object=new Foo（）创建对象的实例。有没有一种方法可以说添加到对象中，以便
（size\u t）object
或
sizeof（*object）
将其显示为更大的对象？另外，当我们说向这个对象强制转换一个标准的数据类型，比如char*时，有没有一种方法来填充这个强制转换，使char*适合它要强制转换的对象的大小？我问这些问题是出于好奇，因为我觉得这可能会解决我的程序中的一个问题。具体情况如下：

T* AddObject()
{
   T* object = new T(); // Here is the new object T=Foo in this case.
   *(T*)(buffer+position) = *object; // Being stored in a char* buffer at current empty position
   T* returnValue = &(*(reinterpret_cast<T*>(buffer+position))); 
   //  ^ Here I try casting the char* buffer@position with the object contents stored inside the buffer.
   return returnValue;
}

T*AddObject（）
{
T*object=new T（）；//这里是本例中的新对象T=Foo。
*（T*）（buffer+position）=*object；//存储在当前空位置的char*缓冲区中
T*returnValue=&（*（重新解释强制转换（缓冲+位置））；
//^在这里，我尝试铸造字符*buffer@position对象内容存储在缓冲区内。
返回值；
}

这样做的问题是，它在某种程度上将其强制转换为T对象，但大小仍然是缓冲区的大小。在main中执行
sizeof（*object）
将显示我认为对象的大小，但是如果我将
Foo*object=new Foo（）
中的
（size\t）对象与
Foo*differentitobj=AddObject（）
中的
（size\t）differentitobj
比较
（size\t）differentitobj
将与
（size\u t）buffer
相同，但与
（size\u t）object
不同。可能是因为我不明白
size\t
代表的不同于
sizeof
内存中对象的位数，我不确定。至少从我的理解来看，
sizeof
表示变量或类型占用的内存量（以字节为单位）
 您是否意识到
（size\u t）object
没有给您任何大小，但这是对象类型
size\u t
（通常定义为无符号int）的（c样式）转换？例如，见本节
sizeof
（参见示例）返回类型为
size\u t
的值，这可能就是您对它产生混淆的原因

您可能想一直使用
sizeof
。不过，要小心传递给
sizeof
的内容<例如，code>sizeof（Foo*）
将为您提供指向
Foo
的指针的大小，而不是
Foo
对象的大小。对于后者，您必须使用
sizeof（Foo）

（sizeof）x
在编译时进行计算，并通过类型定义进行计算；如果
x
是用户定义的类型，即通过结构或类接口定义的类型。因此，除了更改接口之外，无法更改
sizeof
的结果。
如果要在特定地址构建对象，应使用placement new：

T* AddObject()
{
    return new (buffer+position) T();
}

请注意，如果使用此版本的
new
，则不能使用默认删除

sizeof
是一个编译时运算符，它将从类型中生成其值。它不能重载，返回值的类型为
size\t
size\u t
是标准库中定义的无符号整数类型

在编写
（size\u t）differentitobj
时，您可以将
t*
转换为
size\u t
。这是有效的，但通常不是人们想要做的事情。如果要计算两个指针之间精确字节的偏移量，可以说
reinterpret\u cast（pointer1）-reinterpret\u cast（pointer2）

当两个指针具有相同的值（例如
（size\t）differentitobj==（size\t）buffer
）时，表示它们指向相同的对象。（这意味着在您的示例中，
position
必须设置为
0
。）

无论如何，如果确实需要，您应该只使用这些技术，因为指针摆弄会使代码复杂化。
这是您关于如何将对象序列化到内存缓冲区或从内存缓冲区序列化，并最终（可能）通过其他介质序列化对象的想法吗？我这样问是因为（a）有更好的方法，（b）如果你有兴趣在自我管理的内存缓冲区中构建一个对象，我建议你研究一下。无论如何，对象都是使用特定的静态大小进行类型定义的。您不能在运行时更改该定义。但是您可以包含使用堆管理进行增长的成员（例如：一个向量）。@WhozCraig我尝试通过Boost进行序列化，但是Boost的问题是我需要控制对象声明，以允许Boost进行序列化。Atm我无法触及对象声明/定义的位置，因此我必须想出这个解决方法。另外，我更喜欢在容器实现中使用向量，但在这个程序中我受到了限制。谢谢你，因为你和其他人的建议帮我指明了正确的方向。另外，我无法避免发回对象的指针，所以序列化在这种情况下对我没有帮助吗？谢谢！在这个场景中，我宁愿使用sizeof来确定对象的大小，但是编写代码来测试容器的人使用了（size_t）对象，因此我试图找出（size_t）对象代表的是什么。你的建议让我对尺码有了更多的了解。我想知道答案是有用的，但我目前没有足够的代表在这个论坛上这样做。谢谢！新的工作安排解决了我的问题。通常在比较对象时我更喜欢使用sizeof（）运算符，但在这个程序中我被限制使用（size\t）。另外，我喜欢使用更健壮的STL容器来存储容器，比如向量，但仅限于使用char*缓冲区来存储对象。另外，我会支持这个答案b的有用性