Can I construct an object without allocating memory or copying data?

Question

Consider a class 'B' that contains simple char member vars in a certain order.

class B {
    char x1;
    char x2;
    char x3;
    char x4;
}

I have a buffer A that already contains data in the same order as defined in B. Another process has already loaded A with the data.

char A[4];

1. Is it possible to construct an object of type B that contains the data of A, without the constructor copying the data? That is, I want to "overlay" a B object onto the A buffer so I can use B methods on the data, without incurring the overhead of a copy, or the allocation of memory.

2. Assuming there is a solution to question 1, would there be any reason I couldn't also define a class D that derives from B and which has methods that reference the member vars of B, but which itself contains no new member variables?

Answer 1

As unpleasant as it is, there is no legal (Standard-wise) way to achieve that. Instead, you have one illegal, but usually working one (used across plethora of places) or legal, but optimization-dependent.

Regardless of method, this assumes that there is no padding for B members (add [[gnu::packed]] for gcc, or something else for your compiler to B definition to ensure no padding is happening).

First would be illegal one - you can alias the type. This violates strict aliasing rule, but is known to work on many platforms and compilers. Code sample:

const B* b = reinterpret_cast<const B*>(&a[0]);

The second option is to rely on compiler's optimizer. It is often powerful enough to realize there is no need to actually copy the data, and will just use original values. It doesn't happen all the time, and if you rely on this technique in performance-critical section, you better check the generated code and recheck it with every compiler upgrade.

This code assumes an optimization:

B b;
memcpy(&b, &a[0], sizeof(b));
// use b in non-modifying way
// Compilers usually will not issue a copy here, YMMV

Answer 2

Since an A is not a B there is no legal way to treat an A as a B. That said, if A is a standard layout class then you should be able to cast it and it will "Work" but it wont be legal. For example

struct A
{
    char data[6] = "hi 0/";
    int a = 10;
    int b = 20;
};

struct B
{
    char x1;
    char x2;
    char x3;
    char x4;
    char x5;
    char x6;
};

std::ostream& operator <<(std::ostream& os, B& b)
{
    return os << b.x1 << b.x2 << b.x3 << b.x4 << b.x5 << b.x6;
}

int main()
{
    A a;
    B* b = reinterpret_cast<B*>(&a);
    std::cout << *b;
}

This works since the array and the members occupy the same section of memory in each class but this isn't guaranteed. There could be padding after x1 in B which would mean not all members will be mapped to the array.

Now, if you rework B to have an array instead of separate members like

struct A
{
    char data[6] = "hi 0/";
    int a = 10;
    int b = 20;
};

struct B
{
    char data[6];
};

Then you could uses a Union to hold both A and B and since B has the same common initial sequence as A it is legal to use b. That could look like

union Converter
{
    Converter() : a{} {}
    A a;
    B b;
};

std::ostream& operator <<(std::ostream& os, B& b)
{
    return os << b.data;
}

int main()
{
    Converter c;
    std::cout << c.b;
}

And now the cast is gone and we have a guarantee from the standard that this is safe

Answer 3

Yes you can use an existing buffer to construct a new object into it. You would simple use the placement new operator:

class B
{
    char x1;
    char x2;
    char x3;
    char x4;
};

char A[4];


B *b = new(A) B; 

Now b uses the stack memory of A[4]; The code assumes that B is packed without any alignment.

class D : public B
{
public:
   void MyMethod();
};

D *d = new (A) D;

You can add code in a derived class and then use the same approach constructing D.

The following code:

#include <new>

#include <iostream>

struct B
{
    char x1;
    char x2;
    char x3;
    char x4;
};

char A[4] = { 'M','e','o','w' };

int main()
{
    B *b = new (A) B;

    std::cout << "The cat's " << b->x1 << b->x2 << b->x3 << b->x4 << std::endl;

    return 0;
}

Outputs: The cat's Meow

Answer 4

Yes, you can; if you use placement new, as asked here, (https://isocpp.org/wiki/faq/dtors#placement-new), which will specify the memory location for B and documented here (https://isocpp.org/wiki/faq/dtors#placement-new),

But beware of the destructor behavior in using this, and initializers in B would mess things up by overwriting the data. You also need to be very careful about memory alignment and any requirements that the objects have in that regard.

Specific warnings to regard on that page:

You are also solely responsible for destructing the placed object. This is done by explicitly calling the destructor:

ADVICE: Don’t use this “placement new” syntax unless you have to. Use it only when you really care that an object is placed at a particular location in memory. For example, when your hardware has a memory-mapped I/O timer device, and you want to place a Clock object at that memory location.

and DANGER: You are taking sole responsibility that the pointer you pass to the “placement new” operator points to a region of memory that is big enough and is properly aligned for the object type that you’re creating. Neither the compiler nor the run-time system make any attempt to check whether you did this right. If your Fred class needs to be aligned on a 4 byte boundary but you supplied a location that isn’t properly aligned, you can have a serious disaster on your hands (if you don’t know what “alignment” means, please don’t use the placement new syntax). You have been warned.