placement new - constructor inside constructor - c++

Question

We have a base class A, class B derived from A.
Now class B is allocated using placement new operator.
As a part of my code, I have added class C inside class A
Now the placement new just uses malloc of sizeof class B and does not take into account class C.
Class C constructor is called inside the Class B constructor. ( this is my suspect )
I want to know if thats correct. Or do we add the size of class C in the placement new allocation?
if we add up the memory, how do we call the constructor for class C, it would allocate the memory again?
card.h {
class Card
{
private:
char hwModel; // HW/FW model and rev are stored in the
// database to detect change of card type
char hwRev;
char serialNum[EM_CARD_SERIAL_NUM_SIZE];
char fwModel;
char fwRev;
>>>>
public:
class IssuResource *ptrIssuResrc;
void *operator new(size_t size, void *objP) {size = size; return objP;};
// overload the new operator
void operator delete(void *objP) { objP = objP;};
// overload the delete operator
Card();
}
chopperCard.cpp
// Allocate Memory and Create Card Object
/* sa_ignore */
buf = (UINT32 *)malloc(sizeof(CardChop));
if (buf == NULL) {
emLogError(EM_INTERNAL_ERROR, __FUNCTION__,
"exit: failed to allocate %d bytes for card object\n",
sizeof(CardChop)
);
exit(1);
}
/* sa_ignore */
card = new (buf) CardChop(spa_issu_restart); --> placement new
}
Constructor for choppercard:
{
CardChop::CardChop (boolean is_issu_set) : Card()
{
issu_inprogress = is_issu_set;
if (is_issu_set) {
ISSUTRACE(4,"Issu state is SET\n");
dev_np37xx_update_issu_state(is_issu_set);
dev_set_issu_state(is_issu_set);
dev_dm_issu_state(is_issu_set);
dev_tigris_issu_state(is_issu_set);
dev_evros_issu_state(is_issu_set);
dev_evros1_issu_state(is_issu_set);
>>>
vtwin->fvt->set_gp_stat(vtwin, VTWIN_GP_STAT_APP_TRACE1,
CHOP_BG_INIT_FAIL);
// init Bourget device
initDevice((dev_object_t *)bourget);
vtwin->fvt->set_gp_stat(vtwin, VTWIN_GP_STAT_APP_TRACE1, CHOP_BG_INIT_AFTER);
ptrIssuResrc = new IssuResource();
}

Answer 1

Placement new will work JUST like operator new without placement, except that it uses the supplied address rather than allocating from the heap. Since neither forms of operator new will in itself call the actual constructor, the construction is exactly the same either way - the compiler calls the object constructor something like this
T *p = new T;
becomes (not valid syntax, and T::operator new may become ::operator new):
T *p = T::operator new(sizeof(T)); p->T();
with placement, it's nearly the same:
T *p = new(somewhere) T;
becomes (not valid, as above):
T *p = T::operator new(sizeof(T), somewhere); p->T();
If you have something like this:
class C { ... };
class A
{
...
C c;
};
class B: public A
{
...
}
then C's constructor will be called automatically when the constructor of B is called. (And B's constructor will automatically call A's constructor)

Answer 2

The value returned from sizeof includes the sizes of all the bases and members. There is no other concept of size to confuse things.
It looks like the code is excessively complicated. What you are doing with malloc is simply reinventing the default behavior of new.
This does the same thing, but simpler:
card = new CardChop(spa_issu_restart);
if (card == NULL) {
emLogError(EM_INTERNAL_ERROR, __FUNCTION__,
"exit: failed to allocate %d bytes for card object\n",
sizeof(CardChop)
);
exit(1);
}
If using the global, default operator new, you should also remove the operator delete overload.
In fact, the best practice with placement new is not to use delete at all. (Note that you have defined operator delete to do nothing.) The better way is to use a pseudo-destructor call, which looks like
card_ptr->~CardChop(); // execute destructor but no delete
free( card_ptr ); // release placement memory a la delete
Also, note that exit is a potentially unsafe way to terminate the program as it doesn't destroy local objects. Consider throwing an exception instead.