Basic Vector Operations in C++

Welcome to our practice-focused lesson on Basic Vector Operations without Built-in Methods. A vector in C++ is simply an ordered collection of items that can be of any type.

Working with vectors is a fundamental aspect of C++ programming. While C++ indeed offers numerous standard library functions to make operations with vectors quite straightforward, understanding how to perform these operations without using standard library functions can dramatically sharpen your problem-solving skills, improve your knowledge of how data structures work under the hood, and prepare you for programming environments that may not provide such high-level abstractions.

The vector data structure in C++ is a dynamic array that provides flexible storage and manipulation capabilities for collections of items. It is implemented as a class in the C++ Standard Library (std::vector), offering a range of methods and functionalities to manage and interact with elements. Unlike static arrays, std::vector allows its size to dynamically grow and shrink as needed, managing memory allocation and deallocation automatically.

For the purpose of this lesson and practice exercises, you'll need to understand that a vector is essentially a dynamic array, where elements can be accessed and modified via zero-based indexing. Each element in a vector can be individually accessed, modified, and traversed, making it a versatile data structure for many programming tasks.

Basic operations for manipulating vectors manually include:

• Accessing elements by index
• Iterating through the vector
• Inserting and removing elements
• Resizing the vector
• Using .size() to get the length of the vector

Additionally, you should be familiar with the concept of immutability where passing vectors by constant reference (const std::vector<int>&) ensures the original vector is not modified and avoids unnecessary copying of data.

Consider a function that finds the maximum element in a vector without using C++'s built-in algorithms like std::max_element.

Our approach to the findMax challenge is:

1. Initialize Maximum Element: Begin by initializing a variable max_element with the first element of the input vector vec. This will serve as the current largest element found in the vector.

2. Set Up a Loop: Utilize a range-based for loop to iterate through each element in the vector vec.

3. Compare Elements: Within the loop, compare the current element to the max_element.

4. Update Maximum Element: If the current element is greater than max_element, update max_element to this current element.

5. Return the Maximum Element: Once the loop completes, return the max_element which now holds the largest element found in the vector.

Here is how the solution will look:

// Find the maximum element in a vector without using std::max_element

#include <iostream>
#include <vector>

int findMax(const std::vector<int>& vec) {
    int max_element = vec[0];  // Initialize with the first element
    for (int element : vec) {
        if (element > max_element) {
            max_element = element;
        }
    }
    return max_element;
}

// Example usage
int main() {
    std::vector<int> sample_vector = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    std::cout << findMax(sample_vector) << std::endl;  // Output: 9
    return 0;
}