Hello World

#include <iostream>

// Based on 64-bit machines.

// 1. Size of ABC is 16 bytes, 8 bytes for vptr, 1 byte for char a, 7 bytes
// padding.
// 2. The vptr point to the vtable of ABC, the vtable contains the address of
// the virtual functions of ABC: ~ABC(), Interface() and Foo().
// 3. The entry for Interface() in ABC's vtable is effectively a placeholder,
// since Interface() is pure virtual in ABC, it can't directly provide a valid
// function address for this slot, indicating that the derived classes must
// provide an implementation.
// 4. The destrcutor of base class must be virtual, otherwise the derived
// class destructor will not be called when deleting a derived class object
// through a base class pointer.
class ABC {
 public:
  ABC() : a{'z'} {
    std::cout << "Constructing ABC, its size is " << sizeof(ABC)
              << " byte(s).\n";
  }
  virtual ~ABC() { std::cout << "~ABC()" << std::endl; }
  virtual void Interface() = 0;
  virtual void Foo() { std::cout << "Foo() implemented by ABC" << std::endl; }

 public:
  char a;
};

// 1. Size of Derived is also 24 bytes in total, 8 for vptr, 1 for char a
// inherited from ABC, 8 added by Derived's data member double x. Taking into
// amount those members, the raw sum would be 17 bytes.  However, classes and
// structs are commonly aligned to the size of their largest member or the
// platform's word size for efficiency reasons, which in this case aligns
// naturally due to teh presence of the double and the vptr, both being 8 bytes.
// Thus, the char a is padded to 8 bytes.
class Derived : public ABC {
 public:
  Derived() : x{1.2345} {
    std::cout << "Constructing Derived, its size is " << sizeof(Derived)
              << " byte(s).\n";
  }
  ~Derived() override { std::cout << "~Derived()" << std::endl; }
  virtual void Interface() override {
    std::cout << "Interface() implemented by Derived" << std::endl;
  }
  virtual void Foo() override {
    std::cout << "Foo() implemented by Derived" << std::endl;
  }

  void Bar() {
    std::cout << "Bar(), the Derived featured function" << std::endl;
  }

 public:
  // Question: If x is int, how many bytes does Derived occupy?
  // Answer: 16 bytes, 8 for vptr, 1 for char a, 3 padding bytes, 4 for int x.
  // Question: Why the padding 3 bytes for int x, not 7?
  // Answer: The size of int is 4 bytes, so the padding is 3 bytes to make the
  // size of Derived a multiple of 8 bytes.
  double x;
};

int main() {
  Derived d;
  d.Foo();

  // Let's break down the following code.
  // 1. Object creation: The expression new Derived() creates a Derived object
  // in the heap memory. Even though the pointer p is of type ABC*, the object
  // created is of type Derived.
  // 2. Vptr initialization: When a Drived object is created, its constructor
  // initializes the object's vptr to point to Derived's vtable. The vtable
  // contains pointers to Derived's implementations of all virtual funtions.
  // 3. Dynamic dispatch of Foo(): When you call p->Foo(), the vptr in the
  // object(pointed by p) is used to look up the actual function to call via the
  // vtable associated with the object's dynamic type(Derived). Since Derived
  // overrides Foo(), the Foo() implementation in Derived is located in
  // Derived's vtable and gets executed.
  ABC* bp{new Derived()};
  bp->Foo();

  // But do not get mixed up with the code above.
  // Wrong! x is not a member of ABC.
  // The base class ABC has no knowledge of any members that are defined in its
  // derived classess, even though bp actually points to an object of type
  // Derived. This is not polymorphism.
  // std::cout << bp->x << std::endl;
  // To access x, you could downcast bp to a pointer to Derived, like this:
  std::cout << static_cast<Derived*>(bp)->x << std::endl;
  // Alternatively, if you want to ensure the type is correct at runtime, you
  // can use a dynamic cast:
  auto dp{dynamic_cast<Derived*>(bp)};
  if (dp) {
    dp->Bar();
  }

  // ! The polymorphism is implemented by the vptr and vtable mechanism.

  std::cout << bp->a << std::endl;

  return 0;
}