C++ Programming Paradigms - Detailed Explanation with Examples and Summary

1. Procedural Programming Paradigm

Definition:
Procedural programming is based on procedures (functions) that operate on data. It follows a top-down
approach, breaking down a program into a set of functions.

Key Characteristics:
- Focus on procedures (functions).
- Data is passed between functions.
- Less secure as data is often global.
- Step-by-step execution (sequence, selection, loops).

Example:

#include <iostream>
using namespace std;

void display() {
cout << "Hello, World!";
}

int main() {
display();
return 0;
}

Advantages:
- Simple and easy for small programs.
- Easier to trace program flow.

Disadvantages:
- Data is global and less secure.
- Difficult to modify large programs.
- Poor code reusability.

2. Object-Oriented Programming (OOP) Paradigm

Definition:
OOP models real-world objects using classes and objects. It combines data and methods into a single unit
C++ Programming Paradigms - Detailed Explanation with Examples and Summary

(object).

Key Concepts:
- Class: Blueprint for creating objects.
- Object: Instance of a class.
- Encapsulation: Data and methods bundled together; data hidden from outside.
- Inheritance: One class derives properties from another.
- Polymorphism: One function behaves differently based on input.
- Abstraction: Hiding complex details and showing only essential features.

Example:

class Car {
private:
string brand;

public:
void setBrand(string b) { brand = b; }
void display() { cout << "Brand: " << brand << endl; }
};

int main() {
Car car1;
car1.setBrand("Toyota");
car1.display();
return 0;
}

Advantages:
- Encapsulation enhances security.
- Inheritance promotes reusability.
- Polymorphism improves flexibility.
- Abstraction reduces complexity.

Disadvantages:
- Complex for small programs.
- Slightly slower due to additional abstraction layers.

3. Generic Programming Paradigm

C++ Programming Paradigms - Detailed Explanation with Examples and Summary

Definition:
Generic programming enables writing type-independent code using templates. The same logic can work with
different data types.

Key Concepts:
- Template: Blueprint for functions or classes with generic types.
- Function Template: Template for a function.
- Class Template: Template for a class.

Example:

template <typename T>

T add(T a, T b) { return a + b; }

int main() {
cout << add<int>(5, 10) << endl;
cout << add<float>(5.5, 2.3) << endl;
return 0;
}

Advantages:
- Avoids code duplication.
- Increases code reusability.
- Type-safe at compile time.

Disadvantages:
- Complex syntax.
- Error messages can be hard to understand.

4. Functional Programming Paradigm

Definition:
Functional programming treats computation as evaluating functions and avoids changing state and mutable
data.

Key Concepts:
- Lambda Expression: Anonymous function.
- Higher-order Function: Function that takes another function as an argument.
C++ Programming Paradigms - Detailed Explanation with Examples and Summary

Example:

int main() {
auto square = [](int x) { return x * x; };
cout << "Square: " << square(5) << endl;
return 0;
}

Advantages:
- Reduces side effects.
- Improves code readability.
- Useful in parallel programming.

Disadvantages:
- Limited support in C++.
- Less intuitive for beginners.

5. Modular Programming Paradigm

Definition:
Modular programming divides a program into separate modules, each handling a specific task.

Key Concepts:
- Module: A self-contained unit of program logic.
- Header File: Declares functions and classes to be used elsewhere.

Example (Module):

// module.h
void displayMessage();

// module.cpp
#include <iostream>
void displayMessage() { cout << "Hello from Module!" << endl; }

// main.cpp
#include "module.h"
int main() { displayMessage(); return 0; }

Advantages:
C++ Programming Paradigms - Detailed Explanation with Examples and Summary

- Improves readability and maintainability.

- Encourages reusability.

Disadvantages:
- Requires more files and setup.
- Complex for beginners.

6. Metaprogramming Paradigm

Definition:
Metaprogramming involves writing programs that generate or manipulate other programs at compile time.

Key Concepts:
- Templates: Type-independent code.
- Template Specialization: Custom behavior for specific data types.

Example:

template <typename T>

class Display { public: void show() { cout << "Generic Type" << endl; } };

template <>
class Display<int> { public: void show() { cout << "Integer Type" << endl; } };

int main() {
Display<double> obj1; obj1.show();
Display<int> obj2; obj2.show();
return 0;
}

Advantages:
- Compile-time optimizations.
- Flexible and powerful for generic libraries.

Disadvantages:
- Complex syntax and error messages.
- Difficult to debug.

Summary of C++ Paradigms

C++ Programming Paradigms - Detailed Explanation with Examples and Summary

| Paradigm | Key Idea | Key Features | Example Concept |

|----------------------|------------------------------------------|-------------------------------------------|-----------------|
| Procedural | Functions operating on data | Functions, loops | sum(int, int) |
| Object-Oriented (OOP)| Real-world objects | Classes, Encapsulation, Inheritance | class
Car |
| Generic | Type-independent programming | Templates | template<T> |
| Functional | Functions as first-class citizens | Lambda expressions | auto lambda
|
| Modular | Program divided into modules | Header files, separate compilation | module.h
|
| Metaprogramming | Compile-time computation | Templates, Specialization |
template<class T>|