我将对象存储在缓冲区中。现在我知道我不能对对象的内存布局做出假设。
如果我知道对象的整体大小，是否可以创建指向此内存的指针并在其上调用函数？
e.g。说我有以下课程：
[int,int,int,int,char,padding*3bytes,unsigned short int*]
1） 如果我知道这个类的大小为24，我知道它在内存中的起始位置 虽然假设内存布局是可以接受将它转换为指针并调用此对象上的函数来访问这些成员是不安全的？ （c ++是否知道成员的正确位置？）
2） 如果这不安全/没有，除了使用一个构造函数之外还有其他任何方法，它可以获取所有参数并一次从缓冲区中拉出每个参数吗？
编辑：更改了标题，使其更符合我的要求。
答案 0 :(得分：6)
您可以创建一个构造函数来获取所有成员并分配它们，然后使用placement new。
class Foo
{
int a;int b;int c;int d;char e;unsigned short int*f;
public:
Foo(int A,int B,int C,int D,char E,unsigned short int*F) : a(A), b(B), c(C), d(D), e(E), f(F) {}
};
...
char *buf = new char[sizeof(Foo)]; //pre-allocated buffer
Foo *f = new (buf) Foo(a,b,c,d,e,f);
这样做的好处是甚至可以正确生成v表。但是，请注意，如果您使用它进行序列化，则无符号短整数指针在反序列化时不会指向任何有用的东西，除非您非常小心地使用某种方法将指针转换为偏移然后再返回
this指针上的各个方法是静态链接的，只是直接调用函数，this是显式参数之前的第一个参数。
使用this指针的偏移量引用成员变量。如果对象的布局如下：
0: vtable
4: a
8: b
12: c
etc...
a即可访问 this + 4 bytes。
答案 1 :(得分：3)
非虚函数调用直接链接，就像C函数一样。对象（this）指针作为第一个参数传递。调用该函数不需要对象布局的知识。
答案 2 :(得分：3)
基本上你提议做的是读取一堆（希望不是随机的）字节，将它们转换为已知对象，然后在该对象上调用类方法。它实际上可能有效，因为这些字节最终会在该类方法中的“this”指针中结束。但是你真的有机会处理编译代码所期望的事情。与Java或C＃不同，没有真正的“运行时”来捕获这些问题，所以最好你会得到一个核心转储，更糟糕的是你会得到损坏的内存。
听起来你想要一个Java的序列化/反序列化的C ++版本。可能有一个图书馆可以做到这一点。
答案 3 :(得分：2)
听起来你并没有将对象本身存储在缓冲区中，而是存储它们的数据。
如果此数据在内存中按字段在您的类中定义的顺序（对于平台有适当的填充）和，您的类型为POD，那么您可以{{ 1}}来自缓冲区的数据到指向你的类型的指针（或者可能会抛出它，但要注意，有一些特定于平台的陷阱，其中有不同类型的指针）。
如果您的类不是POD，则不保证字段的内存布局，并且您不应该依赖任何观察到的顺序，因为允许在每次重新编译时更改。
但是，您可以使用来自POD的数据初始化非POD。
就非虚函数所在的地址而言：它们在编译时静态链接到代码段中的某个位置，对于您的类型的每个实例都是相同的。请注意，不涉及“运行时”。当你编写这样的代码时：
memcpy编译器生成的代码类似于：
class Foo{
int a;
int b;
public:
void DoSomething(int x);
};
void Foo::DoSomething(int x){a = x * 2; b = x + a;}
int main(){
Foo f;
f.DoSomething(42);
return 0;
}
：
main”f”调用默认初始值设定项（在这种情况下不执行任何操作）Foo推送到堆栈42”推送到堆栈f（实际名称通常更复杂）Foo_i_DoSomething@4加载到累加器寄存器0（位于代码段的其他位置）
Foo_i_DoSomething@4”值（由调用者推送）x”指针（由调用者推送）this对象a”的偏移量
Foo指针，在步骤3中加载this”值x”指针this对象中字段“a”的偏移量
Foo指针，在步骤8中加载this”存储在offset，a”值添加到步骤7中加载的“a”值x”指针this对象b”的偏移量
Foo指针，在步骤14中加载换句话说，它或多或少是相同的代码，就像你写的一样（具体的，例如DoSomething函数的名称和传递this指针的方法由编译器决定）：
this答案 4 :(得分：2)
在这种情况下，已经创建了一个具有POD类型的对象（无论你是否调用new。分配所需的存储已经足够了），你可以访问它的成员，包括调用一个函数宾语。但是只有当你精确地知道T的所需对齐和T的大小（缓冲区可能不小于它）以及T的所有成员的对齐时，这才会起作用。即使对于pod类型，编译器也是如此。如果需要，允许在成员之间放置填充字节。对于非POD类型，如果您的类型没有虚函数或基类，没有用户定义的构造函数（当然）并且也适用于基类及其所有非静态成员，则可以获得相同的运气。
对于所有其他类型，所有投注均已关闭。您必须首先使用POD读取值，然后使用该数据初始化非POD类型。
答案 5 :(得分：2)
我将对象存储在缓冲区中。 ...如果我知道对象的整体大小，是否可以创建指向此内存的指针并在其上调用函数？
在使用演员阵容的情况下，这是可以接受的：
#include <iostream>
namespace {
class A {
int i;
int j;
public:
int value()
{
return i + j;
}
};
}
int main()
{
char buffer[] = { 1, 2 };
std::cout << reinterpret_cast<A*>(buffer)->value() << '\n';
}
将对象转换为原始内存并再次返回实际上很常见，尤其是在C世界中。但是，如果您正在使用类层次结构，则使用指向成员函数的指针会更有意义。
说我有以下课程：...
如果我知道这个类的大小为24，我知道它在内存中的起始位置......
这是事情变得困难的地方。对象的大小包括其数据成员的大小（以及来自任何基类的任何数据成员）加上任何填充以及任何函数指针或依赖于实现的信息，减去从某些大小优化中保存的任何内容（空基类优化）。如果结果数字是0字节，则该对象需要在内存中至少占用一个字节。这些是大多数CPU对内存访问的语言问题和常见要求的组合。 Trying to get things to work properly can be a real pain
如果您只是分配一个对象并在原始内存中进行强制转换，则可以忽略这些问题。但是如果你将一个对象的内部复制到某种缓冲区，那么它们会很快地抬起头。上面的代码依赖于一些关于对齐的一般规则（即，我碰巧知道A类将具有与int相同的对齐限制，因此阵列可以安全地转换为A;但我不一定能保证如果我将数组的一部分转换为A和其他类与其他数据成员的部分，则相同。
哦，当复制对象时，你需要确保正确处理指针。
您可能也对Google's Protocol Buffers或Facebook's Thrift等内容感兴趣。
是的，这些问题很难解决。而且，是的，一些编程语言将它们扫地出门。 But there's an awful lot of stuff getting swept under the rug：
在Sun的HotSpot JVM中，对象存储与最近的64位边界对齐。除此之外，每个对象在内存中都有一个2字的标题。 JVM的字大小通常是平台的本机指针大小。 （一个只包含32位int和64位double - 96位数据的对象将需要）对象头有两个单词，int有一个单词，double有两个单词。这是5个字：160位。由于对齐，此对象将占用192位内存。
这是因为Sun依赖于相对简单的内存对齐问题策略（在假想的处理器上，可以允许char存在于任何内存位置，任何可被4整除的位置的int，以及双可能只需要在可被32整除的内存位置上进行分配 - 但最严格的对齐要求也满足所有其他对齐要求，因此Sun根据最严格的位置对齐所有内容。）
Another tactic for memory alignment can reclaim some of that space
答案 6 :(得分：1)
答案 7 :(得分：0)
这取决于你所说的“安全”。无论何时以这种方式将内存地址转换为某个点，您都会绕过编译器提供的类型安全功能，并对自己负责。如果像Chris所暗示的那样，你对内存布局或编译器实现细节做出了错误的假设，那么你将得到意想不到的结果和松散的可移植性。
由于您担心这种编程风格的“安全性”，因此研究可移植和类型安全的方法（例如预先存在的库，或者为此目的编写构造函数或赋值运算符）是值得的。 p>