Allocating and instantiating an object from a user controlled memory pool - c++

Question

The C++ compiler I'm using is an older version (C++98 maybe?)
I can NOT dynamically allocate memory from the system pool using things like new, malloc
I can however use built-in OS calls to malloc from a heap array defined by me.
I'm running into some strange behavior (program crashes) when I do the following
class cBaseClass /* pure abstract */
{
public:
virtual void ifFunc( void ) = 0;
virtual ~cBaseClass() = 0;
}
inline cBaseClass::~cBaseClass()
{
}
class cDclass:cBaseClass
{
public:
cDclass();
~cDclass();
void ifFunc( void ); /* implement the pure virtual */
}
cDclass::cDclass( void )
{
printf("[0x%X] derived constructor called\n", this);
}
cDclass::~cDclass( void )
{
printf("[0x%X] derived destructor called\n", this);
}
void cDclass::ifFunc(void)
{
printf("[0x%X] ifFunc called from derived class\n", this);
}
uchar_t myHeap[4096];
int main ( void )
{
cDclass* pMyPtr = NULL;
uint32_t i = 0;
( void ) memset( myHeap, 0, sizeof(myHeap)/sizeof(myHeap[0]);
for( i = 0; i < 20; i++)
{
pMyPtr = myHeap[i * sizeof(cDclass) + 4];
*pMyPtr = cDclass();
pMyPtr->ifFunc(); /* Crash */
}
}
What I see is that the constructor for the derived class gets called..then its destructor gets called and then a crash.
Am I mistaken in believing that *pMyPtr = cDclass() constructs a class and then makes a copy of that class at the address specified by pMyPtr?
I say this because when I remove
pMyPtr = cDClass()
and create a dummy variable to store an instance of cDclass and then use memmove it no longer crashes.

Answer 1

The first weird thing is that this line:
pMyPtr = myHeap[i * sizeof(cDclass) + 4];
compiles without complaint. It's implicitly converting a uchar_t to a cDclass*, which shouldn't be possible without a reinterpret_cast. But it could be that your compiler is more lenient there. Anyway, at least you're missing a & operator here.
The second problem is that yes, you are wrong in your assumption. What the line does is construct a temporary object on the stack, then assume that at the pointer location there is already a fully constructed object, call that object's compiler-generated copy assignment operator with the temporary as an argument, then destroy the temporary.
The thing that never happens is that an object is actually constructed in the memory. This means the vptr is never initialized, so the call to the virtual function is a null dereference.
What you need to do is use placement-new to construct an object in-place. Your loop should look like this:
int main ( void )
{
uint32_t i = 0;
( void ) memset( myHeap, 0, sizeof(myHeap)/sizeof(myHeap[0]);
for( i = 0; i < 20; i++)
{
// get the address to construct the object at
uchar_t* pMyAddr = &myHeap[i * sizeof(cDclass) + 4];
// construct a new object in-place at that address
cDclass* pMyPtr = new (pMyAddr) cDclass();
pMyPtr->ifFunc(); /* Don't crash */
}
}
Note that you will be responsible for actually calling the destructor for all the objects you created.

Answer 2

*pMyPtr = cDclass();
Assumes that a valid object already exists at *pMyPtr and uses its assignment operator. (On a typical implementation, this is probably not good enough because it doesn't copy the vptr.)
What you need instead is
new(pMyPtr) cDclass;
to call the constructor at a specified memory location. You'll need to #include <new>.