Inside the C++ Object Model

"default constructors … are generated (by the compiler) where needed….". there are 2 kinds of needs, one is needs of the program, another is need of the compiler. Here, it means latter, moreover, the synthesized constructor performs only those activities required by the compiler.

The synthesis (including default constructor, copy constructor, destructor and assignment copy operator) takes place only if the contructor actually needs to be invoked.since these synthesized functions are inline or non-inline static, it prevent compiler to synthesize multiple these default functions.

Within the synthesized default constructor, only the base class subobjects and member class objects are initialize. All other nonstatic data members are not.

For a class without any constructors, four conditions under which the default constructor generated by compiler are:

• it has one or more Member Class Objects with Default Constructor

No matter synthesized constructor or user defined contructors of the class, these Default Constructors are invoked in the order of Member Class Objects declaration, and before explicit user code.

• it has Base Class with Default Constructor

If Member Class Objects with Default Constructor are also present, they are also invoked after the invocation of all base class constructors.

• it either declare or inherit a virtual function

In order to initialize the vptr for object of the class with the address of proper virtual table, code must be be inserted by compiler to each constructor the class defines. If the class has no user-declared constructor, compiler synthesize a default constructor to initialize the vptr for object of the class.

• it is derived from an inheritance chain in which one or more base classes are virtual

To make the virtual base class location within each derived class object available at runtime,compiler insert code in each constructors. Without user-declared constructor, compiler need to synthesize a default constructor.

If a class does not provide an explicit copy constructor, the class object initiazed with another object of its class is initialized by Default Memberwise Initialization.

Default Memberwise Initialization copies the value of each built-in or derived data member(such as a pointer or an array) from one class object to another.

A member class object, however, is not copied; rather, Memberwise Initialization is recursively applied. How is this operation in practice carried out? Compiler need to synthesize a copy constructor in order to invoke the copy constructor of the member class object. The prereuisite is that the class does not exhibit Bitwise Copy Semantics.

By the way, in case of the synthesized copy constructor, the nonclass members are also copied.

Four instances that a class does not exhibit Bitwise Copy Semantics:

1. the class contains a member object of a class for which a copy constructor(either explicit one or synthesized one) exists
2. the class is derived from a base class for which a copy constructor(either explicit one or synthesized one) exists
3. the class declares one or more virtual functions
4. the class is derived from an inheritance chain in which one or more base classes are virtual

For 1 and 2, compiler needs to insert invocations of the member or base class copy constructors inside the synthesized copy constructor.

For 3, the synthesized copy constructor explicitly sets the object's vptr to the class virtual table rather than coping it from the right-hand class object.

For 4, the synthesized copy constructor is to initialize the virtual base class pointer, to perform necessary memberwise initializations of its members, and to do some other memory tasks.

The rule applies on Copy assignment operator as well.

Two options of initializing class members: either the member initialization list or within constructors. which one you choose is not signigicant, except in 4 cases below you must use the Member Initialization List .

• when initializing a reference member
• when initializing a const member
• when invoking a base constructor with a set of arguments
• when invoking a member class constructor with a set of arguments

Compiler iterates over and possiblt reorders the initialization list to reflect the declaration order of the members. It inserts the code within the body of the constructor prior to any explicit user code.

The static data members are stored in the program's data segment independant of individual class objects.

Within an access section(private, protected or public) of a class object, the nonstatic data members are set down in the order of their declaration.

Within multiple access section of a class object, it is up to compiler to order the nonstaitc data members. In practice, multiple access sections are concatenated together into an contiguous block in the order of declaration.

A derived class object is represented as the concatenation of its members with those of its base class(es). The actual ordering of the derived and base class parts vary from compiler, but, in practice, the base class members always appear first, exept in case of a virtual base class.

Traditionally, vptr is placed after all the explicitly declared members of the class so that it is compatible to struct. More recently, it has been placed at the beginning of the class object so that it is convinient, in case of multiple inheritance, to invoke virtual function by pointer or reference.

what about vbptr ?

class Point3d {
public:
  virtual ~Point3d();
  static Point3d origin;
  float x, y, z;
};
Point3d::~Point3d(){}

int main(){
    Point3d p3d;

  cout<<"&Point3d::x = "<<&Point3d::x<<", &Point3d::y = "<<&Point3d::y<<endl;
  printf("&Point3d::x = %p, &Point3d::y = %p\n", &Point3d::x, &Point3d::y);
  cout<<&p3d<<", "<<&p3d.x<<", "<<&p3d.y<<endl;
  printf("%p, %p, %p", &p3d, &p3d.x, &p3d.y);

  return 0;
}

Output for GCC is shown in table, that is very different from the content in the book.

class Base1 {
public:
  int val1;
};
class Base2 {
public:
  int val2;
};
class Derived: public Base1, public Base2 {};
void func1(int Derived::* dmp, Derived * pd){
  cout<<pd->*dmp<<endl;
}
void func2(Derived* pd){
  int Base2::*bmp = &Base2::val2;
  func1(bmp, pd);
}
int main(){
    Derived d;

  d.val1 = 1;
  d.val2 = 2;

  func2(&d);
}

Output for GCC is 2.

int Derived::* dmp means bmp is a pointer to any data member of type int in class Derived.

Assume a nonstatic member function

Point3d Point3d::normalize() const
{
  register float mag = magnitude();

  return Point3d(_x/mag, _y/mag, _z/mag);
}

Compiler internally transformes it into the equivalent nonmember instance. Steps shown below

• Rewrite the signature to insert an additional argument to the member function that provides access to the invoking class object(this pointer).
• Rewrite each direct access of a nonstatic data member of the class to access the member through the this pointer.
• Rewrite the member function into an external function, mangling its name so that it's lexically unique within the program

Finally, if Point3d has copy constructr and NRV is applied, the member function above becomes

void normalize__7Point3dFv( register const Point3d *const this, Point3d &__result ){
  register float mag = this->magnitude();
  // default constructor
  __result.Point3d::Point3d( this->_x/mag,  __result._y. this->_z/mag );
  return;
}

In C++, the set of virtual functions capable of being invoked through an object of its class is known at compile time, moreover, this set is invariant.

To support polymorphism, a pointer to virtual function table is inserted within each class object, each virtual function is assigned a fixed index within the table.

When a class derives from a base class, it can

• inherit the instance of the virtual function declared within the base class
• override the instance with one of its own
• introduce a new virtual function not present in the base class, then the virtual function table is grown by a slot.

finally, the address of that instance is coppied into the associated slot in the derived class's virtual function table.

• The copy assignment operator is not called by most-drived class directly.
• The synthesized copy assignment operator calls copy assginment operator of its base class.
• The copy assignment operator of base class is not called by user defined copy assignment operator automatically.

class Point {
public:
  Point& operator=(const Point &p);
};
Point& Point::operator=(const Point &p){cout<<"Point::operator="<<endl;}

class Point3d: public virtual Point {
public:
  Point3d& operator=(const Point3d &p);   
};
Point3d& Point3d::operator=(const Point3d &p){cout<<"Point3d::operator="<<endl;}

class Vertex: public virtual Point {
public:
//      Vertex& operator=(const Vertex &p);     
};
//Vertex& Vertex::operator=(const Vertex &p){cout<<"Vertex::operator="<<endl;}

class Vertex3d: public Point3d, public Vertex {
public:
//      Vertex3d& operator=(const Vertex3d &p); 
};
//Vertex3d& Vertex3d::operator=(const Vertex3d &p){cout<<"Vertex3d::operator="<<endl;}

int main() {
  Vertex3d v1;
  Vertex3d v2=v1; // Not trigger copy assignment operator
    cout<<"+++++++++++"<<endl;
  v2 = v1;

  return 0;
}

If a destructor is not defined by a class, the compiler synthesizes one only if the class contains either a member or base class with a destructor. it does not matter if it contains a virtual function or has virtual base class.

A user-defined destructor is argumented in much the same way as are the constructoes, except in reverse order:

• If the object contains vptr, it is reset to the virtual table associated with the class whose destructor is running.
• The body of the destructor is executed.
• If the class has member class objects with destructors, these are invoked in the reverse order of their declaration.
• If there are any immediate nonvirtual base classes with destructors, these are invoked in the reverse order of their declaration.
• If there are any virtual base class with destructors and this class represents the most-derived class, these are invoked in the reverse order of their original construction.