Limitations of OOP in C++

1. Inheritance can increase complexity in deep hierarchies.
2. Object creation requires more memory.
3. Runtime polymorphism adds overhead.
4. Too much abstraction may reduce performance.
5. Error handling can be more complex.
6. Difficult to model functional problems directly.

Advantages of OOP in C++

1. Modularity through Classes
   OOP allows breaking down complex programs into smaller, manageable pieces (classes). This modularity improves organization and makes code easier to understand and debug.
2. Reusability through Inheritance
   Once a class is written, it can be reused using inheritance. New classes can reuse existing functionalities and only add or override what’s needed—saving time and effort.
3. Data Hiding and Security via Encapsulation
   OOP protects internal object details using access specifiers like private and protected, exposing only what’s necessary. This secures the data from accidental modification.
4. Flexibility and Maintainability
   Changes in one part of the code (like one class) typically don’t affect others. This improves maintainability and makes large-scale projects easier to manage.
5. Polymorphism for Dynamic Behavior
   Using polymorphism (especially runtime), you can write code that works with objects of different classes using a common interface, making the system flexible and scalable.
6. Real-World Mapping
   OOP models real-world entities (like Car, Student, Account) directly in code, making logic intuitive and closer to real scenarios.

10.11 Disadvantages of OOP in C++

1. Complexity for Small Programs
   For very small or simple tasks, OOP might feel like overkill. The setup of classes and objects adds unnecessary complexity in such cases.
2. Steep Learning Curve
   Beginners may find concepts like abstraction, inheritance, and polymorphism confusing initially, especially when combined with C++ syntax.
3. Larger Program Size
   OOP adds overhead due to additional abstraction layers, leading to larger compiled binaries compared to procedural code.
4. Slower Execution
   Runtime polymorphism and virtual functions introduce slight performance overhead due to dynamic binding.
5. Design Dependency
   A poorly designed class structure can ruin modularity and make the code even more difficult to manage and debug.
6. More Memory Usage
   Due to multiple objects, pointers, vtables (for virtual functions), and inheritance trees, OOP-based systems typically consume more memory than procedural ones.