Introduction to C++ Programming

• C++ is a high-level, general-purpose programming language

Key Features of C++

• Supports both procedural and object-oriented programming paradigms
• Known for its performance, efficiency, and control over system hardware
• Has a rich library of functions and tools

Basic Syntax

• Statements end with a semicolon (;)
• Code blocks are enclosed in curly braces ({})
• Comments are denoted by // for single-line or /* ... */ for multi-line comments
• int main() is the entry point of a C++ program

Variables and Data Types

• Fundamental data types include int, float, double, char, and bool
• Variables must be declared before use, specifying their data type
• Example: int age = 25;
• const keyword declares a variable as constant, meaning its value cannot be changed after initialization (e.g., const int x = 10;)
• Use auto to automatically deduce the data type of a variable (e.g., auto y = 3.14; // y is a double)

Operators

• Arithmetic operators: +, -, *, /, % (modulus)
• Assignment operators: =, +=, -=, *=, /=, %=
• Comparison operators: == (equal), != (not equal), >, <, >=, <=
• Logical operators: && (AND), || (OR), ! (NOT)
• Increment/Decrement operators: ++, -- (pre and post)

Control Structures

If-Else Statements

• Allows conditional execution of code blocks
• Example: if (age >= 18) { /* code */ } else { /* code */ }

Switch Statement

• Selects one of several code blocks based on the value of a variable
• Requires break statements to prevent fall-through

Loops

For Loop

• Executes a block of code a specified number of times
• Example: for (int i = 0; i < 10; i++) { /* code */ }

While Loop

• Executes a block of code as long as a condition is true
• Example: while (condition) { /* code */ }

Do-While Loop

• Executes a block of code at least once, then repeats as long as a condition is true
• Example: do { /* code */ } while (condition);

Functions

• Blocks of code that perform a specific task
• Defined with a return type, name, and parameters
• Example: int add(int a, int b) { return a + b; }
• Can have default parameter values (e.g., int power(int base, int exponent = 2))
• Function overloading allows multiple functions with the same name but different parameter lists
• inline functions are expanded at the point of call

Arrays

• Collection of elements of the same data type
• Declared with a fixed size
• Example: int numbers[5] = {1, 2, 3, 4, 5};
• Accessed using an index (starting from 0)

Pointers

• Variables that store memory addresses
• Declared using the * operator
• Example: int *ptr = &age; (ptr stores the address of age)
• Dereferencing a pointer (using *) accesses the value at the stored address
• Dynamic memory allocation using new and delete

Strings

• Represent sequences of characters
• C++ supports C-style strings (character arrays terminated by null character '\0')
• The std::string class (from the <string> header) provides more functionality and safety

Classes and Objects

• Fundamental concepts of object-oriented programming
• A class is a blueprint for creating objects
• An object is an instance of a class
• Encapsulation: Bundling of data and methods that operate on that data within a class
• Inheritance: Allows a class to inherit properties and methods from another class (base class)
• Polymorphism: Ability of objects of different classes to respond to the same method call in different ways

Class Members

• Can be public, private, or protected
• public: Accessible from anywhere
• private: Accessible only from within the class
• protected: Accessible from within the class and its derived classes
• Member functions (methods) define the behavior of the class
• Constructor: Special method called when an object is created
• Destructor: Special method called when an object is destroyed

Inheritance

• Allows creating new classes (derived classes) from existing classes (base classes)
• Types of inheritance: single, multiple, hierarchical, multi-level, hybrid
• virtual functions enable runtime polymorphism

Polymorphism

• Achieved through function overloading and virtual functions
• Function overloading: Multiple functions with the same name but different parameters
• Virtual functions: Declared in the base class and overridden in derived classes
• Abstract classes: Classes that contain at least one pure virtual function (virtual function with no implementation)

Templates

• Allow writing generic code that works with different data types
• Function templates: Define a function that can operate on different types
• Class templates: Define a class that can hold different types
• Example: template <typename T> T max(T a, T b) { return (a > b) ? a : b; }

Exception Handling

• Mechanism for handling runtime errors
• try block: Encloses code that might throw an exception
• catch block: Handles a specific type of exception
• throw statement: Throws an exception

Standard Template Library (STL)

• A set of template classes and functions
• Includes containers (e.g., vector, list, map), algorithms (e.g., sort, find), and iterators
• vector: Dynamic array that can grow or shrink in size
• list: Doubly-linked list
• map: Associative container that stores key-value pairs
• Iterators: Objects that allow traversal of containers
• Algorithms: Functions that perform common operations on containers (e.g., searching, sorting)

Namespaces

• Provide a way to organize code into logical groups
• Prevent naming conflicts
• Example: namespace MyNamespace { /* code */ }
• Using directive: using namespace MyNamespace;

Input/Output Streams

• C++ uses streams for input and output operations
• iostream library: Provides cin (standard input), cout (standard output), cerr (standard error)
• Manipulators: Functions that modify the behavior of streams (e.g., endl for newline, setprecision for controlling floating-point precision)
• File I/O: Using fstream library to read from and write to files

Memory Management

• C++ allows manual memory management using new and delete
• new: Allocates memory on the heap
• delete: Frees allocated memory
• Memory leaks: Occur when allocated memory is not freed
• Smart pointers: Classes that automatically manage dynamically allocated memory (e.g., unique_ptr, shared_ptr)