Inside the C++ Object Model 读书笔记(一)

Chapter 1 Object Lessons

In C, there is no language-supported relationship between data and functions. We speak of this method of programming as procedural.

• Layout Costs for Adding Encapsulation
  The member functions, although included in the class declaration, are not reflected in the object layout; one copy only of each non-inline member function is generated. the primary layout and access-time overheads within C++ are associated with the virtuals, that is:
  1. the virtual function mechanism in its support of an efficient run-time binding
  2. a virtual base class in its support of a single, shared instance of a base class occurring multiple times within an inheritance hierarchy.

1.1 The C++ Object Model

Two flavors of class member data: static, nonstatic.Three flavors of class member function: static, nonstatic,

• simple object model

an object is a sequence of slots, where each slot points to a member

this simple concept of an index or slot number is the one that has been developed into the C++ pointer-to-member concept

• table-driven object model

The class object contains the pointers to the two member tables, the one is member data table and the other is member function table.

Although this model is not used in practice within C++, the concept of a member function table has been the traditional implementation supporting efficient runtime resolution of virtual functions

• The C++ Object Model

Nonstatic data members are allocated directly within each class object. Virtual functions are supported in two steps：

1. A table of pointers to virtual functions is generated for each class (this is called the virtual table).
2. A single pointer to the associated virtual table is inserted within each class object (traditionally, this has been called the vptr). The setting, resetting, and not setting of the vptr is handled automatically through code generated within each class constructor, destructor, and copy assignment operator (this is discussed in Chapter 5). The type_info object associated with each class in support of runtime type identification (RTTI) is also addressed within the virtual table, usually within the table’s first slot.

• Adding Inheritance

1.2 A Keyword Distinction

One reasonable use of the C struct in C++, then, is when you want to pass all or part of a complex class object to a C function. This struct declaration serves to encapsulate that data and guarantees a compatible C storage layout.

struct : default public, can’t use in template as class.
class : defautl private, template key word.

struct C_point { ... }; 

class Point { 
public: 
   operator C_point() { return _c_point; } 
   // ... 
private: 
   C_point _c_point; 
   // ... 
}; 

1.3 An Object Distinction

The C++ programming model directly supports three programming paradigms.

1. The procedural model as programmed in C

char boy[] = "Danny"; 
char *p_son; 

... 

p_son = new char[ strlen( boy ) + 1 ]; 
strcpy( p_son, boy ); 

... 

if ( !strcmp( p_son, boy )) 
   take_to_disneyland( boy ); 

2. The abstract data type (ADT) model

String girl = "Anna"; 
String daughter; 

... 

// String::operator=(); 
daughter = girl; 

...
// String::operator==(); 
if ( girl == daughter ) 
   take_to_disneyland( girl ); 

3. The object-oriented (OO) model

void 
check_in( Library_materials *pmat ) 
{ 
   if ( pmat->late() ) 
        pmat->fine(); 
   pmat->check_in(); 
   if ( Lender *plend = pmat->reserved() ) 
        pmat->notify( plend ); 
} 

---

The C++ language supports polymorphism in the following ways:

1. Through a set of implicit conversions, such as the conversion of a derived class pointer to a pointer of its public base type:

shape *ps = new circle(); 

2. Through the virtual function mechanism

ps->rotate(); 

3. Through the dynamic_cast and typeid operators

if ( circle *pc = 
   dynamic_cast< circle* >( ps )) ... 

The memory requirements to represent a class object in general are the following:

• The accumulated size of its nonstatic data members

• Plus any padding (between members or on the aggregate boundary itself) due to alignment constraints (or simple efficiency)

• Plus any internally generated overhead to support the virtuals

1.4 Memory Layout

class Bear : public ZooAnimal { 
public: 
   Bear(); 
   ~Bear(); 
   // ... 
   void rotate(); 
   virtual void dance(); 
   // ... 
protected: 
   enum Dances { ... }; 

   Dances dances_known; 
   int cell_block; 
}; 

Bear b( "Yogi" ); 
Bear *pb = &b; 
Bear &rb = *pb; 

{ 
   ZooAnimal za; 
   ZooAnimal *pza; 

   Bear b; 
   Panda *pp = new Panda; 

   pza = &b; 
} 

To summarize, polymorphism is a powerful design mechanism that allows for the encapsulation of related types behind an abstract public interface, such as our Library_materials hierarchy. The cost is an additional level of indirection, both in terms of memory acquisition and type resolution. C++ supports polymorphism through class pointers and references. This style of programming is called object-oriented.