C++ Object-Oriented Programming (OOP)

• C++ is a versatile programming language supporting various programming paradigms, with object-oriented programming (OOP) being a core feature.
• OOP in C++ enables the creation of modular, reusable, and maintainable code through the use of objects and classes.
• Four fundamental principles of OOP are encapsulation, inheritance, polymorphism, and abstraction.

Encapsulation

• Encapsulation is the bundling of data (attributes) and methods (functions) that operate on that data into a single unit, known as a class.
• It restricts direct access to some of the object's components, a mechanism known as data hiding.
• Access specifiers (private, protected, public) control the visibility and accessibility of class members.
• Private members are only accessible from within the same class, ensuring data integrity.
• Protected members are accessible from the same class and its derived classes, allowing for inheritance while maintaining some level of data hiding.
• Public members are accessible from anywhere, providing an interface for interacting with the object.
• Getters (accessors) and setters (mutators) are public methods used to access and modify private data members, providing controlled access.
• Encapsulation reduces complexity and increases robustness by preventing unintended modifications to an object's internal state.

Inheritance

• Inheritance allows a new class (derived class or subclass) to inherit properties and behaviors from an existing class (base class or superclass).
• It promotes code reuse and establishes a hierarchical relationship between classes.
• Different types of inheritance exist: single inheritance (one base class), multiple inheritance (multiple base classes), multilevel inheritance (inheritance from a derived class), and hierarchical inheritance (multiple derived classes from a single base class).
• The class DerivedClass : access_specifier BaseClass syntax is used to specify inheritance in C++.
• The access specifier in inheritance (public, protected, private) determines the accessibility of inherited members in the derived class.
• When inheriting publicly, public members of the base class remain public in the derived class, and protected members remain protected.
• When inheriting protectedly, public and protected members of the base class become protected in the derived class.
• When inheriting privately, public and protected members of the base class become private in the derived class.
• Constructors and destructors are not inherited, but the derived class constructor can call the base class constructor to initialize the inherited members.
• The order of constructor and destructor calls follows a specific pattern: base class constructor(s) are called first, followed by the derived class constructor; destructors are called in the reverse order.
• Virtual functions in the base class allow derived classes to override the base class implementation providing polymorphism.
• Abstract classes are classes that cannot be instantiated and are designed to serve as base classes, defining a common interface for their derived classes.
• Abstract classes contain at least one pure virtual function (declared with = 0).

Polymorphism

• Polymorphism enables objects of different classes to be treated as objects of a common type.
• It allows a single interface to represent different underlying forms.
• Two main types of polymorphism in C++ are compile-time (static) and run-time (dynamic) polymorphism.
• Compile-time polymorphism is achieved through function overloading and operator overloading.
• Function overloading allows multiple functions with the same name but different parameters within the same scope.
• Operator overloading allows operators to be redefined to work with user-defined types (classes).
• Run-time polymorphism is achieved through virtual functions and inheritance.
• A virtual function is a member function declared with the virtual keyword in the base class.
• When a virtual function is called through a pointer or reference to the base class, the actual function executed is determined by the type of the object being pointed to or referenced at run-time.
• This is known as late binding or dynamic binding.
• If a derived class overrides a virtual function, it provides its own implementation of that function.
• If a derived class does not override a virtual function, it inherits the base class's implementation.
• Pure virtual functions are virtual functions that have no implementation in the base class and are declared with = 0.
• A class containing at least one pure virtual function is an abstract class.
• Dynamic polymorphism allows for more flexible and extensible code.

Abstraction

• Abstraction involves simplifying complex reality by modeling classes based on essential characteristics, ignoring non-essential details.
• It provides a simplified view of an object, focusing on what it does rather than how it does it.
• Abstract classes and interfaces are used to achieve abstraction in C++.
• An abstract class defines a common interface for its derived classes without providing a complete implementation.
• Derived classes provide the specific implementations for the abstract methods, tailoring the behavior of the object to its specific type.
• Abstraction helps in managing complexity and promoting code reusability.
• It allows developers to focus on the essential features of an object, hiding the underlying complexity.

Classes and Objects

• A class is a blueprint or template for creating objects.
• It defines the data members (attributes) and member functions (methods) that an object of that class will have.
• An object is an instance of a class.
• It is a concrete entity that exists in memory and has its own set of data values.
• Objects are created using the class name followed by the object name (e.g., ClassName objectName;).
• The new operator can also be used to dynamically allocate memory for an object on the heap.
• Objects can access the data members and member functions of their class using the dot operator (.) or the arrow operator (->) (for pointers to objects).
• Constructors are special member functions that are automatically called when an object is created.
• They are used to initialize the object's data members.
• Destructors are special member functions that are automatically called when an object is destroyed.
• They are used to release any resources held by the object.
• The this pointer is a special pointer that points to the current object.
• It is used to access the object's members from within its own member functions.

Object-Oriented Design Principles

• SOLID principles are a set of five design principles intended to make software designs more understandable, flexible, and maintainable.
• Single Responsibility Principle (SRP): A class should have only one reason to change.
• Open/Closed Principle (OCP): Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.
• Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types without altering the correctness of the program.
• Interface Segregation Principle (ISP): Many client-specific interfaces are better than one general-purpose interface.
• Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions.
• Other object-oriented design principles include:
  • Don't Repeat Yourself (DRY): Avoid redundancy in code.
  • Keep It Simple, Stupid (KISS): Design for simplicity.
  • You Ain't Gonna Need It (YAGNI): Don't add functionality until deemed necessary.

Advantages of OOP

• Modularity: OOP promotes the creation of modular code by organizing it into classes and objects.
• Reusability: Inheritance allows classes to inherit properties and behaviors from other classes, reducing code duplication and promoting reuse.
• Maintainability: Encapsulation and abstraction make it easier to understand and maintain code by hiding complexity and isolating changes.
• Extensibility: Polymorphism allows new classes to be added to a system without modifying existing code.
• Data hiding: Encapsulation protects data from unauthorized access, improving data integrity.

Disadvantages of OOP

• Complexity: OOP can be more complex than procedural programming, especially for large and complex systems.
• Overhead: OOP can introduce some performance overhead due to the use of dynamic binding and virtual functions.
• Steep learning curve: Mastering OOP concepts and design principles can take time and effort.
• Potential for inappropriate use: Overuse or misuse of OOP principles can lead to overly complex and difficult-to-maintain code.