C++ Exception Handling

• C++ is a high-level, general-purpose programming language.
• Bjarne Stroustrup developed C++ as an extension of the C language.
• C++ supports both procedural and object-oriented programming paradigms.
• It is known for its performance and is used in developing system software, game development, drivers, client-server applications and embedded firmware.

Exception Handling

• Exception handling is a mechanism to handle runtime errors (exceptions) that may occur during program execution.
• It provides a way to transfer control to error handlers instead of terminating the program abruptly.
• Keywords used: try, catch, and throw.
• The try block encloses the code that might throw an exception.
• The catch block catches and handles the thrown exception.
• The throw statement is used to throw an exception.
• Example:

try {
 // Code that might throw an exception
 if (errorCondition) {
 throw std::runtime_error("An error occurred");
 }
} catch (const std::runtime_error& error) {
 // Handle the exception
 std::cerr << "Exception caught: " << error.what() << std::endl;
}

• Benefits include improved error management and program robustness.
• Exceptions can be standard exceptions (e.g., std::runtime_error, std::out_of_range) or user-defined exceptions.
• Uncaught exceptions will typically lead to program termination.

Standard Template Library (STL)

• The STL is a set of template classes and functions in C++ that provide common programming data structures and algorithms.
• It consists of containers, algorithms, iterators, and function objects (functors).
• Containers are data structures like vectors, lists, queues, stacks, maps, and sets.
• Algorithms are functions that perform operations on containers, such as sorting, searching, and transforming.
• Iterators are used to traverse containers and provide access to elements.
• Function objects (functors) are objects that can be called like functions, often used as arguments to algorithms.
• Example:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6};
std::sort(numbers.begin(), numbers.end());

for (int num : numbers) {
 std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}

• Key containers: vector, list, deque, set, map, unordered_set, unordered_map.
• Key algorithms: sort, find, transform, copy, erase.
• Iterators allow generic algorithms to work with different container types.
• Functors enable customization of algorithm behavior.

Templates and Generics

• Templates are a feature in C++ that allows writing generic code that can work with different data types without being rewritten for each type.
• They enable writing functions and classes that operate on data without specifying the data type at the time of writing the code.
• There are two types of templates: function templates and class templates. Template syntax:

template <typename T>
T myFunction(T a, T b) {
 return a + b;
}

• typename keyword is used to define a template type parameter. class keyword also can be used instead of typename.

Function Templates

• Function templates are used to create generic functions.
• The compiler generates different versions of the function for each data type used.
• Example:

template <typename T>
T max(T a, T b) {
 return (a > b) ? a : b;
}


int main() {
int x = 5, y = 10;
std::cout << max(x, y) << std::endl; // Output: 10
double p = 5.5, q = 10.5;
std::cout << max(p, q) << std::endl; // Output: 10.5
return 0;
}

Class Templates

• Class templates are used to create generic classes.
• Allow defining classes that can operate on different data types.
• Example:

template <typename T>
class MyVector {
private:
 T* data;
 int size;
public:
 MyVector(int size) : size(size) {
 data = new T[size];
 }
 ~MyVector() {
 delete[] data;
 }
 T& operator[](int index) {
 return data[index];
 }
};


int main() {
MyVector<int> intVector(10);
intVector[0] = 5;
std::cout << intVector[0] << std::endl; // Output: 5


MyVector<double> doubleVector(5);
doubleVector[0] = 3.14;
std::cout << doubleVector[0] << std::endl; // Output: 3.14
return 0;
}

• Enables code reuse and type safety.
• Reduces code duplication.

Memory Management

• C++ provides manual memory management using pointers and operators like new and delete.
• Dynamic memory allocation allows allocating memory during runtime.
• new operator allocates memory on the heap.
• delete operator deallocates memory allocated with new.
• Memory leaks occur when dynamically allocated memory is not properly deallocated.
• Dangling pointers occur when a pointer points to a memory location that has already been deallocated.
• Smart pointers (e.g., std::unique_ptr, std::shared_ptr, std::weak_ptr) help automate memory management and prevent memory leaks.
• Example of manual memory management:

int* ptr = new int; // Allocate memory for an integer
- ptr = 10; // Assign a value
std::cout << *ptr << std::endl; // Access the value
delete ptr; // Deallocate the memory
ptr = nullptr; // Set the pointer to null to avoid dangling pointer issues

• Smart pointers automatically manage the lifetime of dynamically allocated objects.
• Example of using smart pointers:

#include <memory>


int main() {
std::unique_ptr<int> ptr(new int(10)); // Allocate memory using unique_ptr
std::cout << *ptr << std::endl; // Access the value
// Memory is automatically deallocated when ptr goes out of scope
return 0;
}

• unique_ptr provides exclusive ownership, shared_ptr allows shared ownership, and weak_ptr provides non-owning access.

Object-Oriented Programming (OOP)

• OOP is a programming paradigm based on the concept of "objects," which contain data (attributes) and code (methods) to manipulate that data.
• Key principles: Encapsulation, Inheritance, Polymorphism, Abstraction.
• Encapsulation: Bundling data and methods that operate on the data within a class, and hiding the internal implementation details from the outside world.
• Inheritance: Allows a class (subclass or derived class) to inherit properties and behaviors from another class (base class or parent class).
• Polymorphism: Allows objects of different classes to be treated as objects of a common type. Achieved through method overriding and interfaces.
• Abstraction: Simplifying complex reality by modeling classes based on essential characteristics, hiding unnecessary details.
• Classes and Objects:
• A class is a blueprint or template for creating objects.
• An object is an instance of a class.
• Example:

class Animal {
public:
 // Constructor
 Animal(std::string name) : name(name) {}
 
 // Virtual function to allow derived classes to override
 virtual void makeSound() {
 std::cout << "Generic animal sound" << std::endl;
 }
 
 // Getter for name
 std::string getName() const { return name; }
 
private:
 std::string name;
};


class Dog : public Animal {
public:
 Dog(std::string name) : Animal(name) {}
 
 // Override makeSound function
 void makeSound() override {
 std::cout << "Woof!" << std::endl;
 }
};


int main() {
Animal* myAnimal = new Animal("GenericAnimal");
Dog* myDog = new Dog("Buddy");


myAnimal->makeSound(); // Output: Generic animal sound
myDog->makeSound();  // Output: Woof!


delete myAnimal;
delete myDog;


return 0;
}

• Benefits include code reusability, modularity, and easier maintenance.
• Helps model real-world entities and relationships.