SOLID Principles

SOLID Principles

• Single Responsibility Principle (SRP): A class should have only one reason to change, meaning it should have only one job.
• Focuses on high cohesion, where elements within a module are closely related.
• Benefits include easier testing, reduced coupling, and improved code clarity.
• Open/Closed Principle (OCP): Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.
• Allows adding new functionality without altering existing code.
• Achieved through abstraction and polymorphism.
• Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types without altering the correctness of the program.
• Ensures that derived classes can be used wherever their base classes are used, without unexpected behavior.
• Requires careful design of inheritance hierarchies.
• Interface Segregation Principle (ISP): A client should not be forced to depend on methods it does not use.
• Advocates for creating smaller, more specific interfaces instead of large, general-purpose ones.
• Reduces coupling and promotes code reusability.
• Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.
• Decouples high-level and low-level modules by introducing abstractions.
• Enhances flexibility, maintainability, and testability.

Encapsulation Violation

• Public variables violate encapsulation.
• Direct access to public variables from outside the class bypasses the control mechanisms provided by encapsulation.

Default Access Specifier in C++

• The default access specifier for members in a C++ class is private.
• If no access specifier (public, protected, or private) is specified, the member is considered private by default.

Virtual Functions

• Virtual functions are commonly used to implement polymorphism.
• Polymorphism allows objects of different classes to be treated as objects of a common type.
• Virtual functions enable dynamic dispatch, where the correct function to call is determined at runtime based on the object's actual type.

Non-Creatable Class

• Objects of abstract classes can't be created.
• Abstract classes contain at least one pure virtual function (a virtual function declared with = 0).
• Abstract classes serve as interfaces, defining a common set of methods that concrete subclasses must implement.

Function Overloading

• If a class contains the same function name with different signatures (input parameters), function overloading is exploited.
• Allows defining multiple functions with the same name but different parameter lists within the same scope.
• The compiler determines which overloaded function to call based on the arguments provided in the function call.

Inaccessible Members in Derived Classes

• Private members can't be accessed in derived classes of a base class.
• Private members are only accessible within the class in which they are declared.
• Derived classes cannot directly access or modify private members of their base classes.

Destructor Call Order in Inheritance

• When an object of class C (inheriting from B, which inherits from A) is destroyed, the destructors are called in the following order: C, then B, then A.
• Destructors are called in the reverse order of construction.
• The most derived class's destructor is called first, followed by the destructors of its base classes in reverse order of inheritance.

Multiple Inheritance in C++

• A class can inherit from multiple other classes in C++.
• C++ supports multiple inheritance, where a class can inherit features from multiple base classes.
• This allows combining the characteristics of different classes into a single class.

Object Creation Limit

• The number of objects of a specific class that can be created in a single program is generally limited by available memory.
• Without specific restrictions, you can create as many objects as memory allows.
• Limiting object creation might be relevant with creational design patterns like Singleton, but not by default.

Purpose of Coding Styles

• Coding styles promote code readability, consistency, and maintainability.
• Establish a set of rules and guidelines for formatting code, naming conventions, and coding practices.
• Improve code comprehension and collaboration among developers.

Unit Tests

• Unit tests are automated tests that verify the behavior of individual units of code (e.g., functions, methods, classes).
• Goals include:
• Ensuring that each unit of code works as expected.
• Detecting bugs early in the development process.
• Facilitating code refactoring and maintenance.
• Providing documentation for the code's behavior.
• Good unit tests are:
• Isolated: Test a single unit of code in isolation, without dependencies on other units.
• Fast: Execute quickly to enable frequent testing.
• Repeatable: Produce the same results every time they are run.
• Self-validating: Automatically determine whether the test passed or failed.
• Comprehensive: Cover all important scenarios and edge cases.

Object-Oriented Analysis vs. Object-Oriented Design

• Object-Oriented Analysis (OOA): Focuses on understanding and modeling the problem domain.
• Involves identifying the objects, classes, and relationships that are relevant to the problem.
• Creates a conceptual model of the system, describing what the system should do.
• Object-Oriented Design (OOD): Focuses on creating a blueprint for the software system.
• Involves defining the classes, interfaces, and relationships that will be used to implement the system.
• Translates the conceptual model from OOA into a concrete design that can be implemented in code.

Deep Copy vs. Shallow Copy

• Shallow Copy: Creates a new object but only copies the references to the original object's data.
• Both the original and the copied object point to the same memory locations.
• Changes made to the data in one object will affect the other.
• Deep Copy: Creates a new object and recursively copies all the data from the original object.
• The original and copied objects have their own independent copies of the data.
• Changes made to the data in one object will not affect the other.

Overloading vs. Templates in C++

• Overloading: Allows defining multiple functions with the same name but different parameter lists within the same scope.
• Useful when you need to perform similar operations on different data types.
• Requires writing separate function definitions for each data type.
• Templates: Allows writing generic code that can work with different data types without having to write separate code for each type.
• Uses placeholders for data types, which are replaced by the compiler at compile time.
• Reduces code duplication and improves code reusability.