Managing C ++ objects in a buffer with alignment and layout assumptions

It looks like you are not storing the objects themselves in the buffer, but rather the data they are made of.

If this data is in memory in the order in which the fields are defined in your class (with the correct padding for the platform) and , your type is POD , you can memcpy

buffer the data to a pointer to your type (or perhaps cast it, but be careful. there are some platform-specific hotchs with throws to different types of pointers).

If your class is not a POD, then the in-memory layout of the fields is not guaranteed and you should not rely on any observable ordering, as this is allowed to change on every recompilation.

You can, however, initialize a non-POD with data from the POD.

Regarding addresses where non-virtual functions are located: they are statically linked at compile time somewhere in your code segment, which is the same for every instance of your type. Note that the "runtime" is not involved. When you write code like this:

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;
}

      

        
        
        
      

    

the compiler generates code that does something like this:

• Function main
  
  :
  • allocate 8 bytes on the stack for object " f
    
    "
  • call the default initializer for the class " Foo
    
    " (does nothing in this case)
  • the value of the push argument onto 42
    
    the stack
  • push the pointer to the object " f
    
    " on the stack
  • make a function call Foo_i_DoSomething@4
    
    (the actual name is usually more complex)
  • load return value 0
    
    to battery register
  • return to caller
• Function Foo_i_DoSomething@4
  
  (located elsewhere in the code segment)
  • load " x
    
    " a value from the stack (push to the caller)
  • multiply by 2
  • load " this
    
    " the pointer from the stack (pushed by the caller)
  • calculate field offset " a
    
    " inside the objectFoo
    
    
  • add the computed offset to the pointer this
    
    loaded in step 3
  • save the product calculated in step 2 for the offset calculated in step 5
  • load the x
    
    value from the stack, again
  • load the this
    
    pointer from the stack, again
  • calculate the field offset " a
    
    " inside the object Foo
    
    , again
  • add the computed offset to the pointer this
    
    loaded in step 8
  • load " a
    
    " the value saved with the offset,
  • add the value " a
    
    " loaded by int step 12 to the value " x
    
    " loaded in step 7
  • load the this
    
    pointer from the stack, again
  • calculate field offset " b
    
    " inside the objectFoo
    
    
  • add the computed offset to the pointer this
    
    loaded in step 14
  • store the sum calculated in step 13 for the offset calculated in step 16
  • return to caller

class Foo{
    int a;
    int b;

    friend void Foo_DoSomething(Foo *f, int x);
};

void Foo_DoSomething(Foo *f, int x){
    f->a = x * 2;
    f->b = x + f->a;
}

int main(){
    Foo f;
    Foo_DoSomething(&f, 42);
    return 0;
}

      

        
        
        
      

    

• An object of type POD, in this case, has already been created (whether you call new or not). Allocating the required storage is already enough) and you can access its members, including calling a function on that object. But this will only work if you know exactly the required alignment of T and the size of T (the buffer can be at least this) and the alignment of all T members. Even for the pod type, the compiler is allowed to put spaces between the members if it wants to. For non-POD types, you may have the same luck if your type has no virtual functions or base classes, no specific constructor (of course), and this also applies to the base and all of its non-static members.

• For all other types, all bets are disabled. You must first read the values ​​using a POD and then initialize the non-POD type with that data.

I store objects in a buffer .... If I know the total size of an object, is it acceptable to create a pointer to that memory and call functions on it?

This is acceptable to the extent that the use of drops is acceptable:

#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';
}

      

        
        
        
      

    

Passing an object to and from something like raw memory is actually quite common, especially in the C world. However, if you are using a class hierarchy, it would make more sense to use a pointer to member functions.

Let's say I have the following class: ...

if I know this class is 24 in size and I know the address where it starts in memory ...

This is where things get tricky. The size of an object includes the size of its data items (and any data members from any base classes) plus any padding plus any function pointers or implementation-dependent information, minus anything saved when optimizing for a specific size (empty base class optimization) ... If the resulting number is 0 bytes, then the object must accept at least one byte in memory. These things are a combination of language issues and general requirements that most processors have in relation to memory access. Trying to make things work properly can be a real pain .

If you just allocate an object and pronounce it in and out of raw memory, you can ignore these issues. But if you copy the internal objects to some kind of buffer, then they quickly cover the head. The above code relies on a few general alignment rules (i.e., I know that class A will have the same alignment constraints as ints, and thus the array can be safely referenced to A, but I could not guarantee that same if I were doing parts of array A and parts to other classes with other data members).

Oh, and when copying objects you need to make sure you handle pointers correctly.

You may also be interested in things like Google Protocol Buffers or Facebook Thrift .

Yes, these problems are complex. And, yes, some programming languages ​​sweep them under the rug. But there's an awful lot of things covered under the carpet :

In Sun HotSpot JVM, object storage is aligned to the nearest 64-bit boundary. In addition, each object has a 2-word header in memory. The JVM word size is usually the size of the embedded platform pointer. (An object consisting of only 32-bit int and 64-bit binary - 96 data bits) would require two words for the object header, one word for an int, two words for a double. That's 5 words: 160 bits. Due to alignment, this object will occupy 192 bits of memory.

This is because Sun relies on a relatively simple tactic for memory alignment problems (on an imaginary processor, char could be allowed to exist anywhere in memory, int anywhere that is divisible by 4, and double might only need to be allocated on memory locations which is divisible by 32, but the strictest alignment requirement also satisfies every other alignment requirement, so Sun aligns everything according to the most restrictive location).

Another memory alignment tactic can reclaim some of that space .

• If the class does not contain virtual functions (and therefore the instance instances do not have a vptr), and if you make the right assumptions about how the item element data is put into memory, then doing what you suggest might work (but might not be portable ).
• Yes, another way (more idiomatic, but not much safer ... you still need to know how the class exposes its data) would be to use the so-called "new placement operator" and the default constructor.