C++ Tutorial

1. C++ Get Started

C++ is a popular programming language that is widely used for system/software development, game programming, and more. To start with C++, you need to install a C++ compiler like GCC (GNU Compiler Collection) or an IDE like Code::Blocks, Visual Studio, or Dev-C++.

Example: Basic “Hello, World!” Program

cpp
#include <iostream> // Required for input/output
using namespace std; // Allows use of standard library functions without "std::"

int main() {
    cout << "Hello, World!"; // Prints "Hello, World!" to the console
    return 0;
}

In this program:

• #include <iostream> includes the Input/Output Stream library.
• using namespace std; allows us to use standard functions without prefixing std::.
• int main() is the starting point of any C++ program.
• cout outputs text to the console.

2. C++ Syntax

The syntax of C++ is the set of rules that define the structure of a C++ program. C++ programs are case-sensitive and follow specific conventions for declaring and initializing variables, functions, etc.

Example: Basic Syntax Structure

cpp
#include <iostream>
using namespace std;

int main() {
    int x = 5; // Declares an integer variable x with a value of 5
    int y = 10;
    int sum = x + y; // Adds x and y
    cout << sum; // Prints the result (15)
    return 0;
}

• Semicolon (;): End each statement with a semicolon.
• Braces ({}): Used to define a block of code, such as the contents of main().

3. C++ Output

The cout object is used to output data to the console. It is part of the iostream library and allows us to display text and variable values.

Example: Using cout for Output

cpp
#include <iostream>
using namespace std;

int main() {
    cout << "Hello, C++!" << endl; // Outputs "Hello, C++!" and moves to a new line
    int number = 42;
    cout << "The number is: " << number << endl; // Outputs "The number is: 42"
    return 0;
}

• << Operator: Directs data to cout.
• endl: Moves the cursor to the next line.

4. C++ Comments

Comments are notes in the code that are not executed. They are used to explain and document code for readability.

Example of Single-Line and Multi-Line Comments

cpp
#include <iostream>
using namespace std;

int main() {
    // This is a single-line comment
    cout << "Hello, comments!" << endl;

    /*
      This is a multi-line comment
      explaining the code below.
    */
    cout << "Comments help make code readable!" << endl;

    return 0;
}

• Single-Line Comments: Start with //.
• Multi-Line Comments: Start with /* and end with */.

5. C++ Variables

Variables are used to store data that can be used and manipulated in the program. Each variable has a data type, a name, and a value.

Example of Declaring and Using Variables

cpp
#include <iostream>
using namespace std;

int main() {
    int age = 25; // Integer variable
    double height = 5.9; // Double variable (decimal)
    char grade = 'A'; // Character variable
    string name = "Alice"; // String variable

    cout << "Name: " << name << endl;
    cout << "Age: " << age << endl;
    cout << "Height: " << height << endl;
    cout << "Grade: " << grade << endl;

    return 0;
}

In this example:

• int: Stores whole numbers.
• double: Stores decimal numbers.
• char: Stores single characters.
• string: Stores text.

6. C++ User Input

C++ uses cin for input, allowing users to input data that the program can process.

Example of Using cin for User Input

cpp
#include <iostream>
using namespace std;

int main() {
    int age;
    cout << "Enter your age: ";
    cin >> age; // Takes input and stores it in variable age
    cout << "You are " << age << " years old." << endl;

    return 0;
}

• cin: Reads user input.
• >> Operator: Directs the input into the variable.

7. C++ Data Types

Data types define the type of data a variable can hold. Common data types in C++ include int, double, char, string, and bool.

Example of Different Data Types

cpp
#include <iostream>
using namespace std;

int main() {
    int num = 10;         // Integer
    double price = 9.99;  // Double
    char letter = 'A';    // Character
    string word = "Hello"; // String
    bool isActive = true; // Boolean

    cout << "Integer: " << num << endl;
    cout << "Double: " << price << endl;
    cout << "Char: " << letter << endl;
    cout << "String: " << word << endl;
    cout << "Boolean: " << isActive << endl;

    return 0;
}

• int: Integer numbers (e.g., 1, -20, 100).
• double: Decimal numbers (e.g., 5.99, -2.5).
• char: Single character (e.g., 'A', 'b').
• string: Text or sequence of characters.
• bool: Boolean values (true or false).

These fundamental concepts lay the groundwork for understanding and working with C++. Practicing each of these basics will make it easier to tackle more complex topics, such as functions, classes, and file handling. Let me know if you’d like to go deeper into any specific topic or cover additional concepts!

C++ Operators

Operators perform operations on variables and values. C++ has various types of operators, including:

• Arithmetic Operators: Used for mathematical calculations.

  • + (Addition), - (Subtraction), * (Multiplication), / (Division), % (Modulus)

  Example:

  cpp
  int a = 10;
  int b = 3;
  int sum = a + b;
  int remainder = a % b;
  cout << "Sum: " << sum << ", Remainder: " << remainder;
  

• Assignment Operators: Assign values to variables.

  • = (Assign), +=, -=, *=, /=, %=

  Example:

  cpp
  int x = 5;
  x += 3; // Equivalent to x = x + 3;
  cout << "New x value: " << x;
  

• Comparison Operators: Compare two values.

  • ==, !=, <, >, <=, >=

  Example:

  cpp
  int a = 10, b = 20;
  cout << (a < b); // Outputs 1 (true)
  

• Logical Operators: Used for combining conditions.

  • && (AND), || (OR), ! (NOT)

  Example:

  cpp
  bool isSunny = true;
  bool isWarm = false;
  cout << (isSunny && isWarm); // Outputs 0 (false)
  

C++ Strings

Strings are used to store text. In C++, they are part of the <string> library.

Example:

cpp
#include <iostream>
#include <string>
using namespace std;

int main() {
    string greeting = "Hello";
    string name = "Alice";
    string message = greeting + ", " + name + "!";
    cout << message;
    return 0;
}

Explanation:

• + can be used to concatenate strings.
• You can access characters using indexing, e.g., greeting[0] would give 'H'.

C++ Math

The <cmath> library provides several mathematical functions.

Example:

cpp
#include <iostream>
#include <cmath>
using namespace std;

int main() {
    cout << "Square root of 16: " << sqrt(16) << endl;
    cout << "Power of 2^3: " << pow(2, 3) << endl;
    cout << "Absolute value of -10: " << abs(-10) << endl;
    return 0;
}

Functions:

• sqrt(x): Returns the square root of x.
• pow(x, y): Returns x raised to the power y.
• abs(x): Returns the absolute value of x.

C++ Booleans

Booleans are variables that hold true or false values. They are often used in conditions.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    bool isEven = (10 % 2 == 0);
    cout << "Is 10 even? " << isEven;
    return 0;
}

C++ If…Else

The if...else statement is used for decision-making based on conditions.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    int age = 18;

    if (age >= 18) {
        cout << "You are eligible to vote.";
    } else {
        cout << "You are not eligible to vote.";
    }
    return 0;
}

Explanation:

• if checks a condition.
• else runs if the if condition is false.

C++ Switch

The switch statement is an alternative to multiple if...else statements, useful when checking a variable against several constant values.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    int day = 3;

    switch(day) {
        case 1: cout << "Monday"; break;
        case 2: cout << "Tuesday"; break;
        case 3: cout << "Wednesday"; break;
        default: cout << "Other day"; break;
    }
    return 0;
}

Explanation:

• switch compares the variable (day) with each case.
• break prevents fall-through to the next case.

C++ While Loop

The while loop repeats a block of code as long as a specified condition is true.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    int i = 0;

    while (i < 5) {
        cout << "Value of i: " << i << endl;
        i++;
    }
    return 0;
}

Explanation:

• The loop continues as long as i < 5.
• i++ increments i in each iteration.

These topics cover fundamental aspects of C++ programming. Practice writing small programs using each of these concepts to solidify your understanding.

C++ For Loop

The for loop is often used when the number of iterations is known. It has three parts: initialization, condition, and increment.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; i++) {
        cout << "Iteration: " << i << endl;
    }
    return 0;
}

Explanation:

• int i = 0: Initializes i to 0.
• i < 5: The loop runs as long as i is less than 5.
• i++: Increases i by 1 after each iteration.

C++ Break/Continue

The break statement exits a loop immediately, while continue skips the current iteration and proceeds to the next one.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            continue; // Skip when i is 5
        }
        if (i == 8) {
            break; // Stop loop when i is 8
        }
        cout << i << " ";
    }
    return 0;
}

Explanation:

• continue: Skips printing 5.
• break: Ends the loop when i reaches 8.

C++ Arrays

Arrays store multiple values of the same type in a single variable, indexed from 0.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};
    
    for (int i = 0; i < 5; i++) {
        cout << "Element " << i << ": " << numbers[i] << endl;
    }
    return 0;
}

Explanation:

• int numbers[5]: Declares an integer array with 5 elements.
• numbers[i]: Accesses each element by index.

C++ Structures

Structures (struct) are user-defined data types that group related variables. They’re useful for complex data models.

Example:

cpp
#include <iostream>
using namespace std;

struct Student {
    string name;
    int age;
    float gpa;
};

int main() {
    Student student1;
    student1.name = "Alice";
    student1.age = 20;
    student1.gpa = 3.8;

    cout << "Name: " << student1.name << ", Age: " << student1.age << ", GPA: " << student1.gpa;
    return 0;
}

Explanation:

• Student structure groups name, age, and gpa.
• student1 is a variable of type Student.

C++ Enums

Enumerations (enum) define a set of named integral constants, which improves code readability.

Example:

cpp
#include <iostream>
using namespace std;

enum Weekday { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };

int main() {
    Weekday today = Wednesday;

    if (today == Wednesday) {
        cout << "It's midweek!";
    }
    return 0;
}

Explanation:

• Weekday defines constant values for days of the week.
• today is a variable of type Weekday set to Wednesday.

C++ References

A reference is an alias for an existing variable, which allows you to modify the original variable directly.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    int value = 10;
    int &ref = value; // ref is a reference to value

    ref += 5; // Modifies value directly
    cout << "Value: " << value; // Outputs 15
    return 0;
}

Explanation:

• int &ref = value: ref is a reference to value, so changes to ref affect value.

C++ Pointers

Pointers are variables that store the memory address of another variable. They are useful for dynamic memory management, among other things.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    int value = 42;
    int *ptr = &value; // ptr holds the address of value

    cout << "Value: " << value << endl;
    cout << "Pointer Address: " << ptr << endl;
    cout << "Dereferenced Value: " << *ptr; // Accesses value at ptr
    return 0;
}

Explanation:

• int *ptr = &value: ptr is a pointer storing the address of value.
• *ptr: Dereferences the pointer to access the value stored at the memory address.

These concepts are powerful tools in C++, offering more flexibility in data management and control flow. Practice implementing each one in simple programs to strengthen your understanding.

C++ Functions

Functions in C++ are blocks of code designed to perform a specific task. They can be defined with or without parameters and may or may not return a value.

Example:

cpp
#include <iostream>
using namespace std;

void greet() { // Function declaration and definition
    cout << "Hello, welcome to C++ programming!";
}

int main() {
    greet(); // Function call
    return 0;
}

Explanation:

• void greet(): A function named greet with no return value (void) and no parameters.
• greet();: Calls the function from main, outputting a greeting.

C++ Function Parameters

Functions can take parameters to operate on specific inputs. You can pass parameters by value (copy of the variable) or by reference (directly modify the variable).

Example (by value):

cpp
#include <iostream>
using namespace std;

void displayNumber(int num) { // Function with a parameter
    cout << "Number: " << num;
}

int main() {
    int number = 10;
    displayNumber(number); // Passes 10 to the function
    return 0;
}

Example (by reference):

cpp
#include <iostream>
using namespace std;

void increment(int &num) { // Pass by reference
    num++;
}

int main() {
    int number = 5;
    increment(number); // Modifies number directly
    cout << "Incremented number: " << number; // Outputs 6
    return 0;
}

Explanation:

• Pass by Value: A copy of num is passed, so the original variable is unaffected.
• Pass by Reference: &num allows the function to modify number directly.

C++ Function Overloading

Function overloading allows you to define multiple functions with the same name but different parameter lists. The compiler distinguishes them by their parameter types or numbers.

Example:

cpp
#include <iostream>
using namespace std;

void print(int i) {
    cout << "Integer: " << i << endl;
}

void print(double d) {
    cout << "Double: " << d << endl;
}

void print(string s) {
    cout << "String: " << s << endl;
}

int main() {
    print(10);        // Calls print(int)
    print(3.14);      // Calls print(double)
    print("Hello");   // Calls print(string)
    return 0;
}

Explanation:

• The print function is overloaded to handle different data types (int, double, and string).

C++ Scope

Scope determines where a variable can be accessed in your code. C++ has three main types of scope:

• Local Scope: Variables declared within a function.
• Global Scope: Variables declared outside any function, accessible throughout the program.
• Block Scope: Variables defined inside {}.

Example:

cpp
#include <iostream>
using namespace std;

int globalVar = 100; // Global variable

int main() {
    int localVar = 10; // Local variable
    
    if (true) {
        int blockVar = 5; // Block-scoped variable
        cout << "Block variable: " << blockVar << endl;
    }
    
    cout << "Global variable: " << globalVar << endl;
    cout << "Local variable: " << localVar << endl;
    // cout << blockVar; // Error: blockVar is not accessible here
    return 0;
}

Explanation:

• globalVar is accessible anywhere in the program.
• localVar is only accessible within main.
• blockVar is only accessible within the if block.

C++ Recursion

Recursion is when a function calls itself. Recursive functions have a base case to prevent infinite loops. They’re useful for tasks that can be broken down into similar subtasks.

Example (Factorial):

cpp
#include <iostream>
using namespace std;

int factorial(int n) {
    if (n <= 1) {
        return 1; // Base case
    } else {
        return n * factorial(n - 1); // Recursive case
    }
}

int main() {
    int num = 5;
    cout << "Factorial of " << num << " is " << factorial(num);
    return 0;
}

Explanation:

• The factorial function calls itself with n - 1 until n reaches 1.
• The base case (n <= 1) prevents infinite recursion.

These topics cover key aspects of working with functions in C++. Practicing each of these concepts with examples will help solidify your understanding and improve your programming skills in C++.

C++ Classes

A class is a blueprint for creating objects. It defines data members (attributes) and member functions (methods) that operate on the data.

Example:

cpp
#include <iostream>
using namespace std;

class Car {
public:
    string brand;
    int year;

    void honk() {
        cout << "Beep beep!";
    }
};

int main() {
    Car myCar;
    myCar.brand = "Toyota";
    myCar.year = 2020;
    cout << myCar.brand << " " << myCar.year << endl;
    myCar.honk();
    return 0;
}

Explanation:

• Car is a class with attributes brand and year.
• honk is a method that outputs a message.

C++ OOP

Object-Oriented Programming (OOP) in C++ allows you to structure your code using objects and classes. The core principles of OOP include encapsulation, inheritance, and polymorphism.

C++ Classes/Objects

An object is an instance of a class. Objects contain their own copies of the class’s attributes and can use its methods.

Example:

cpp
#include <iostream>
using namespace std;

class Book {
public:
    string title;
    string author;
};

int main() {
    Book myBook;
    myBook.title = "1984";
    myBook.author = "George Orwell";
    cout << myBook.title << " by " << myBook.author;
    return 0;
}

Explanation:

• myBook is an object of the Book class, with its own title and author attributes.

C++ Class Methods

Class methods are functions defined within a class to operate on its data members.

Example:

cpp
#include <iostream>
using namespace std;

class Person {
public:
    string name;

    void introduce() {
        cout << "Hi, I'm " << name << endl;
    }
};

int main() {
    Person person;
    person.name = "Alice";
    person.introduce();
    return 0;
}

Explanation:

• introduce is a method that prints the name attribute of the object.

C++ Constructors

A constructor is a special method called when an object is created. It initializes the object’s attributes.

Example:

cpp
#include <iostream>
using namespace std;

class Rectangle {
public:
    int width, height;

    Rectangle(int w, int h) { // Constructor
        width = w;
        height = h;
    }

    int area() {
        return width * height;
    }
};

int main() {
    Rectangle rect(5, 10);
    cout << "Area: " << rect.area();
    return 0;
}

Explanation:

• Rectangle(int w, int h) is a constructor that initializes width and height.

C++ Access Specifiers

Access specifiers control the visibility of class members. Common ones include:

• public: Accessible from anywhere.
• private: Accessible only within the class.
• protected: Accessible in derived classes.

Example:

cpp
#include <iostream>
using namespace std;

class BankAccount {
private:
    double balance;

public:
    void setBalance(double b) {
        balance = b;
    }

    double getBalance() {
        return balance;
    }
};

Explanation:

• balance is private and cannot be accessed directly. setBalance and getBalance provide controlled access.

C++ Encapsulation

Encapsulation is bundling data and methods within a class and restricting direct access to some of the data. This is achieved by using access specifiers.

Example:

cpp
#include <iostream>
using namespace std;

class Employee {
private:
    string name;
    double salary;

public:
    void setName(string n) { name = n; }
    string getName() { return name; }

    void setSalary(double s) { salary = s; }
    double getSalary() { return salary; }
};

C++ Inheritance

Inheritance allows a class to acquire properties and behavior from another class. The derived class can access the public and protected members of the base class.

Example:

cpp
#include <iostream>
using namespace std;

class Animal {
public:
    void speak() {
        cout << "Animal sound";
    }
};

class Dog : public Animal {
public:
    void bark() {
        cout << "Woof!";
    }
};

int main() {
    Dog myDog;
    myDog.speak();
    myDog.bark();
    return 0;
}

Explanation:

• Dog inherits from Animal and gains access to its speak method.

C++ Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common base class. It often involves method overriding.

Example:

cpp
#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() { // Virtual function
        cout << "Some animal sound" << endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        cout << "Meow" << endl;
    }
};

int main() {
    Animal* animal = new Cat();
    animal->sound(); // Outputs "Meow"
    delete animal;
    return 0;
}

Explanation:

• sound is a virtual function, allowing Cat to override it.

C++ Files

File handling in C++ uses <fstream> to read from and write to files.

Example:

cpp
#include <iostream>
#include <fstream>
using namespace std;

int main() {
    ofstream myFile("example.txt");
    myFile << "Hello, file!";
    myFile.close();

    ifstream readFile("example.txt");
    string line;
    while (getline(readFile, line)) {
        cout << line << endl;
    }
    readFile.close();
    return 0;
}

C++ Exceptions

Exceptions handle runtime errors, providing a way to respond to unusual conditions.

Example:

cpp
#include <iostream>
using namespace std;

int main() {
    try {
        int age = 15;
        if (age < 18) {
            throw "Underage exception!";
        }
    } catch (const char* e) {
        cout << "Error: " << e << endl;
    }
    return 0;
}

C++ Date

C++ does not have a built-in date class, but you can use <ctime> to work with dates and times.

Example:

cpp
#include <iostream>
#include <ctime>
using namespace std;

int main() {
    time_t now = time(0);
    char* dt = ctime(&now);
    cout << "Current date and time: " << dt;
    return 0;
}

These concepts form the basis of effective C++ programming, particularly in OOP design. Practice implementing these to become comfortable with each.

C++ Data Structures & STL

The Standard Template Library (STL) provides a set of classes and functions that allow for flexible, reusable, and efficient data structures. Key data structures include vectors, lists, stacks, queues, deques, sets, maps, and more. STL also provides algorithms that work with these structures, like sorting, searching, and manipulating data.

C++ Vectors

A vector is a dynamic array that can resize itself automatically. It allows for random access to elements and efficient insertion/removal at the end.

Example:

cpp
#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> numbers = {1, 2, 3, 4};
    numbers.push_back(5); // Adds an element at the end

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

Explanation:

• vector<int> numbers: Declares a vector of integers.
• push_back: Adds an element at the end.

C++ List

A list is a doubly linked list that allows efficient insertion and deletion at any position but does not allow random access to elements.

Example:

cpp
#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> numbers = {1, 2, 3, 4};
    numbers.push_back(5);
    numbers.push_front(0); // Adds an element at the beginning

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

Explanation:

• push_front: Adds an element at the start of the list.
• push_back: Adds an element at the end of the list.

C++ Stack

A stack is a LIFO (Last In, First Out) data structure that allows insertion and removal of elements only from the top.

Example:

cpp
#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    s.push(1); // Adds an element to the top
    s.push(2);
    s.push(3);

    while (!s.empty()) {
        cout << s.top() << " "; // Accesses the top element
        s.pop(); // Removes the top element
    }
    return 0;
}

Explanation:

• push: Adds an element to the stack.
• top: Returns the top element.
• pop: Removes the top element.

C++ Queue

A queue is a FIFO (First In, First Out) data structure, where elements are inserted at the back and removed from the front.

Example:

cpp
#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q;
    q.push(1);
    q.push(2);
    q.push(3);

    while (!q.empty()) {
        cout << q.front() << " "; // Accesses the front element
        q.pop(); // Removes the front element
    }
    return 0;
}

Explanation:

• push: Adds an element to the back of the queue.
• front: Returns the front element.
• pop: Removes the front element.

C++ Deque

A deque (double-ended queue) allows insertion and deletion from both the front and back, making it more flexible than a queue.

Example:

cpp
#include <iostream>
#include <deque>
using namespace std;

int main() {
    deque<int> dq;
    dq.push_back(1);
    dq.push_front(0);
    dq.push_back(2);

    for (int num : dq) {
        cout << num << " ";
    }
    return 0;
}

Explanation:

• push_front: Adds an element at the front.
• push_back: Adds an element at the back.

C++ Set

A set is a collection of unique elements. It does not allow duplicates and automatically arranges elements in ascending order.

Example:

cpp
#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> numbers = {3, 1, 4, 1, 5};
    numbers.insert(2);

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

Explanation:

• insert: Adds an element. If the element is a duplicate, it is ignored.

C++ Map

A map is a collection of key-value pairs. Each key is unique, and it maps to a specific value.

Example:

cpp
#include <iostream>
#include <map>
using namespace std;

int main() {
    map<string, int> scores;
    scores["Alice"] = 90;
    scores["Bob"] = 85;

    for (auto pair : scores) {
        cout << pair.first << ": " << pair.second << endl;
    }
    return 0;
}

Explanation:

• scores["Alice"] = 90;: Maps the key “Alice” to the value 90.

C++ Iterators

Iterators are objects that point to elements in containers. They allow for traversal of container elements.

Example:

cpp
#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> numbers = {1, 2, 3, 4};

    for (vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
        cout << *it << " ";
    }
    return 0;
}

Explanation:

• begin(): Returns an iterator to the start of the vector.
• end(): Returns an iterator to one past the last element.

C++ Algorithms

The STL provides many built-in algorithms that operate on data structures, such as sort, find, reverse, and count.

Example (Sorting):

cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

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

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

Explanation:

• sort: Sorts the elements in ascending order.

Example (Finding an element):

cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    vector<int> numbers = {1, 2, 3, 4};
    auto it = find(numbers.begin(), numbers.end(), 3);

    if (it != numbers.end()) {
        cout << "Element found at index: " << distance(numbers.begin(), it);
    } else {
        cout << "Element not found";
    }
    return 0;
}

Explanation:

• find: Searches for the element in the range and returns an iterator to it.

These data structures and algorithms provide powerful tools for managing and manipulating data efficiently in C++. Practicing with each will help you become comfortable with using STL in various programming scenarios.