C++ internals can be better understood by mapping them to corresponding C code.
Refer to the article mapping from C++ classes and methods to C structs and functions.
The contents of the article are summarized below.
This pointer maps to an additional parameter
A C++ method maps to a C method with an additional this pointer. For example, the UpdateX
method C++ method…
void A::UpdateX(int newX) { if (g_y != 0 && m_x < newX) { m_x = newX; } }
…translates to the following C code:
void A_UpdateX(A *this_ptr, int newX) { if (g_y != 0 && this_ptr->m_x < newX) { this_ptr->m_x = newX; } }
Complete article: Mapping from C++ classes and methods to C structs and functions.
A class maps to a struct with associated methods
A C++ class is equivalent to a C structure with a class methods. The following class…
class A { private: int m_x; static int g_y; int m_z; // Should be invoked when the object ends void InformEnd(); public: A(int x); ~A(); void UpdateX(int newX); static void UpdateY(int newY); };
…is represented as the C structure with functions.
- Methods have a corresponding this pointer.
- Static methods are functions that do not get an additional this pointer.
- Static variables map to global variables.
struct A { int m_x; int m_z; }; int g_y = 0; /* Represents static variable */ A *A_Constructor(A *this_ptr, int x); void A_Destructor(A *this_ptr, BOOLEAN dynamic); void A_UpdateX(A *this_ptr, int newX); void A_UpdateY(int newY); /* Represents a static method. */
Complete article: Mapping from C++ classes and methods to C structs and functions.
Constructor representation in C
In C++, objects may be allocated on the heap or the stack. This has implications in the mapping from a C++ constructor to an initialization function in C.
A::A(int x) { m_x = x; m_z = 0; }
The mapped constructor takes an additional this pointer. A NULL is passed as the this pointer when the object has to be allocated on the heap. A valid stack address is passed when an object is on the stack.
If a NULL pointer is passed to the construction function, it allocates memory before performing the initialization.
A *A_Constructor(A *this_ptr, int x) { /*Check if memory has been allocated for struct A. */ if (this_ptr == NULL) { /*Allocate memory of size A. */ this_ptr = (A *) malloc(sizeof(A)); } /* Once the memory has been allocated for A, initialize members of A. */ if (this_ptr) { this_ptr->m_x = x; this_ptr->m_z = 0; } return this_ptr; }
Complete article: Mapping from C++ classes and methods to C structs and functions.
Destructor representation in C
Destructors also deal with deletion of stack and heap objects.
A::~A() { InformEnd(); }
If the object was allocated on the heap, a boolean is passed to signal to the construction function that the memory was allocated dynamically and needs to be freed.
void A_Destructor(A *this_ptr, BOOLEAN dynamic) { InformEnd(this_ptr); /* If the memory was dynamically allocated for A, explicitly free it. */ if (dynamic) { free(this_ptr); } }
Complete article: Mapping from C++ classes and methods to C structs and functions.
Pingback: C++ Internals: Mapping Inheritance and Virtual Functions to C | telecom • networking • design
January 6, 2013 at 12:44 pm
great article, some useful stuff about c++ classes can be found here http://www.byte-notes.com/classes-c