Object-Oriented Programming Basics

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. C++ is a multi-paradigm language with strong support for OOP, while JavaScript uses a prototype-based object model.

Class and Object Definition

In C++, a class is a blueprint for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions). An object is an instance of a class.

Constructors and Destructors

Constructors are special member functions that are automatically called when an object is created. They are used to initialize the object's state.

Destructors are special member functions that are automatically called when an object is destroyed (goes out of scope or is deleted). They are used to clean up resources (e.g., deallocate dynamically allocated memory).

Encapsulation and Access Control

Encapsulation is the bundling of data (member variables) and methods (member functions) that operate on the data into a single unit (class), and restricting direct access to some of the object's components. This is achieved using access specifiers:

• public: Members are accessible from anywhere.
• private: Members are only accessible from within the class itself.
• protected: Members are accessible from within the class and by derived classes.

Basic Inheritance

Inheritance is a mechanism where a new class (derived class or subclass) is created from an existing class (base class or superclass). The derived class inherits properties and behaviors from the base class, promoting code reuse.

Polymorphism Concept

Polymorphism (meaning "many forms") allows objects of different classes to be treated as objects of a common base class. In C++, polymorphism is primarily achieved through virtual functions and pointers/references to base classes.

Comparison with JavaScript Prototype Chain

JavaScript's object model is prototype-based, not class-based in the traditional sense (though ES6 classes provide syntactic sugar). When you try to access a property or method on an object, JavaScript first looks for it directly on the object. If not found, it looks on the object's prototype, then on the prototype's prototype, and so on, forming a prototype chain.

Key Differences:

• Inheritance Model: C++ uses classical inheritance (class-based), while JavaScript uses prototypal inheritance.
• Explicit vs. Implicit: C++ inheritance is explicit with keywords like class and public/private/protected. JavaScript's prototypal inheritance is more implicit.
• Polymorphism: C++ relies on virtual functions and base class pointers/references for runtime polymorphism. JavaScript achieves polymorphism naturally due to its dynamic nature and prototype chain.

Virtual Function Mechanism

In C++, a virtual function is a member function that is declared within a base class and redefined (overridden) by a derived class. When you call a virtual function through a pointer or reference to the base class, the specific version of the function that is executed is determined at runtime based on the actual type of the object being pointed to or referenced. This is known as dynamic dispatch or runtime polymorphism.

• virtual keyword: Declares a function as virtual in the base class.
• override keyword (C++11): Optional, but good practice in derived classes to indicate that a function is intended to override a virtual function from a base class. Helps catch errors if the signature doesn't match.
• Virtual Table (vtable): Compilers typically implement virtual functions using a virtual table, which is a lookup table of function pointers.

---

Practice Questions:

1. Explain the concepts of encapsulation and inheritance in C++. How do access specifiers (public, private, protected) relate to encapsulation?
2. What is polymorphism in C++, and how is it achieved using virtual functions? Provide a simple C++ code example demonstrating runtime polymorphism.
3. Compare and contrast C++'s class-based inheritance with JavaScript's prototype-based inheritance. What are the main differences in how they achieve object-oriented principles?

Project Idea:

• Design and implement a simple Shape hierarchy in C++ using inheritance and polymorphism. Create base class Shape with a virtual calculateArea() method. Derive Circle and Rectangle classes from Shape, each overriding calculateArea() to provide their specific implementation. Then, create an array of Shape pointers and demonstrate calling calculateArea() polymorphically for different shapes.