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.