VECTORS IN C++

A generic container of objects of the same type that is an alternative to C++ fields. In other words, they are dynamic lists. Unlike arrays whose dimension does not change, with vectors it can change dynamically. The array declaration is:

int arr[3]={4,2,7}

Here, the dimensions (3) must be specified in square brackets and cannot be changed further.
Unlike a sheet, the dimension of a vector can be changed during the program.

Include header file: vector

In order to be able to use a vector in our program, it needs to be included using the directive #include:

#include < vector >

The following line should be added below that, which defines the use of the std namespace:

using namespace std;

Otherwise, you would have to write std::vector every time you want to call a vector
Example of vector usage:

#include < vector >
using namespace std;
vector < int > a(10);

This is the declaration of a vector whose data is of type int
Here is:

vector-vector identification
<int> - data type used in the vector, in this case integer
a - vector name

Accessing the elements of a vector is similar to that of arrays. For example. We would approach the 3rd member of the vector as follows:
a[3]

Basic Manipulation of std::vector in C++

This example illustrates how to use std::vector for dynamic array management.

It demonstrates adding elements using push_back, iterating through the vector using a range-based loop, and retrieving the vector size with size().

#include <iostream>
#include <vector>

using namespace std;

int main() {

    vector<int> numbers;

    // Adding elements to the vector
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);

    // Printing vector elements
    cout << "Vector elements: ";
    for (int num : numbers) {
        cout << num << " ";
    }

    // Number of elements
    cout << "\nVector size: " << numbers.size() << endl;

    return 0;
}

Vector methods in C++

Some of the methods for working with vectors in c++:

Adding an element to the end of a vector

Method push_back
example of adding the number 13 to the end of vector a:

a.push_back(13);

Vector size in c++

The size of the vector can be determined by the method. Usage example:

#include < vector >
using namespace std;
vector < int > b={10,20,30,40,50};
cout << "Number of elements of the vector is " << b.size() << "." << endl;

Taking the first element from a vector

The first element of the vector can be obtained by the method vector::front().

#include <vector>
using namespace std;

vector<string> groups = {"Michael", "Peter", "Lazar", "Natasha"};

cout << "The first in the group is " << groups.front() << endl;

The output would show: Michael

Retrieving the last element in a vector

The last element can be retrieved from the vector using the method vector::back(). For example. in the previous group vector example, the last a group member would be:

#include <vector>
using namespace std;

vector<string> group = {"Michael", "Peter", "Lazar", "Natasha"};

cout << "The last one in the group is " << group.back() << endl;

The output would show: Natasha

Inserting a value at a specific position in a vector

Suppose an arbitrary dynamic sequence of numbers is given:

vector < int > numbers={0, 4, 11, 6};

If we want e.g. to replace the new number 5 with the existing number 11, which is in position 2 in the sequence, we can do it as follows:

numbers[2] = 5;

or using the at function:

numbers.at(2) = 5;

The array after modification would look like:

{0, 4, 5, 6};

It can be observed that in this way the value that was previously in the inserted position is deleted. If we want to keep the previous element and insert a new one, then the insert function should be used. For example, if we wanted to now add the value 3 to position 1, then we could do it like this:

int pos = 1;
auto itr=numbers.begin() + pos;
numbers.insert(itr, 3);

After that the array would look like

{0, 3, 4, 5, 6};

We can see that the value 3 has been inserted in position 1 and the value 4 which was previously in that position has moved to position 2.
A array of values can also be added to a specific position. For example. if at position 3 now, we want to insert the following array:

{11, 12, 13};

they would do it like this:

int pos = 3;
auto itr=numbers.begin() + pos;
numbers.insert(itr, {11, 12, 13});

The string after insertion would look like:

{0, 3, 4, 5, 11, 12, 13, 6};

Deleting the last element of the vector

The last element of the vector can be deleted by the method vector::pop_back
The following example shows the application of this method:

#include <vector>
using namespace std;

vector<double> temperatures = {23.2, 25.8, 11, 15.3, 17};

temperatures.pop_back();

After this command the vector values are: 23.2, 25.8, 11, 15.3

Deleting a vector element at a specific position

vector::erase(it) will delete the element of the vector pointed to by the iterator it
Example:

#include < vector >
using namespace std;
vector < int > c={2,3,4};
c.erase(c.begin() + 1);//deletes the element at position 1 in the vector

After deletion, the elements of the vector are: 2, 4

Deleting all vector elements in c++

If we want to empty the vector, ie. to delete all its elements we can use the method vector::clear()
Usage example:

#include < vector >
using namespace std;
vector < int > c={2,3,4};
c.clear();//deletes all elements in the vector

After this, the vector will be empty

Printing the elements of a vector

Let the following vector be given:

#include < vector >
using namespace std;
vector < int > numbers={1,2,3,4,5};

Example of printing numbers to standard output:

for(int i = 0; i < brojevi.size(); i++)
{

cout << numbers[i] << " ";

}
cout << endl;

On the output: 1 2 3 4 5

Test your code here!

// Write your C++ code here...

Enter input for the program:

Reading text data from standard input and inserting one by one into a vector

The <string> header must also be included. Using a while loop, one word at a time is loaded and added to the vector:

#include <vector>
#include <iostream>
#include <string>

using namespace std;

// Declare a vector of strings to store the input words
vector<string> text;

// Variable to hold each word from input
string word;

// Read words from standard input until EOF or an error occurs
while(cin >> word)
{

// Add each word to the vector
text.push_back(word);

}

Iterating through the elements of a vector using an iterator []

In order to print the words entered into the vector in the previous example on the standard output, the following code must be executed:

cout << "Words in the text::\n" << endl;
for(int i = 0; i < text.size(); i++)
{

cout << text[i] << " ";

}
cout << endl;

Iterating through the elements of a vector using an iterator

The following code demonstrates the use of an iterator to loop through the elements of a vector

#include < vector >
using namespace std;
vector < int > points={5,3,5,7,8,2,3,4};
cout << "Number of points per task:\n " << endl;
for(vector < int >::iterator it=points.begin(); it != points.end(); ++it)
{

cout << *it << " ";

}
cout << endl;

The following functions are also implemented in the previous code:

v.begin() – returns an iterator pointing to the initial element of the container
v.end() – returns an iterator pointing "behind the last" element of the container.

Sorting vectors in c++ with the sort library function

The sort function is located in the <algorithm> header, which must be included at the beginning of the file.

#include < algorithm >

The parameters to be passed are pointers to the first and last element to be sorted in the array. If it is necessary to sort the entire array then the code would be as in the following example:

#include < vector >
using namespace std;
vector < int > A={4,2,7,5,9};
sort(a.begin(),a.end());
//printing

Important std::vector Methods

Vectors in C++ provide many useful methods for managing dynamic arrays. Below are the basic methods, along with examples demonstrating their usage.

Basic Methods

Method	Description
push_back()	Adds an element to the end of the vector.
pop_back()	Removes the last element from the vector.
size()	Returns the number of elements in the vector.
clear()	Deletes all elements from the vector.
at()	Accesses an element at a specified index with bounds checking.

Examples of Method Usage

1. Adding Elements – push_back()

The push_back() method is used for dynamically adding elements to a vector.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    numbers.push_back(10); // Adds 10
    numbers.push_back(20); // Adds 20
    
    std::cout << numbers[0] << ", " << numbers[1] << "\n";

    return 0;
}

2. Removing Elements – pop_back()

The pop_back() method removes the last element from the vector.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30};
    numbers.pop_back(); // Removes 30
    
    std::cout << numbers.size() << "\n"; // Prints 2

    return 0;
}

3. Getting Size – size()

The size() method returns the number of elements in the vector.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4};
    std::cout << "Vector size: " << numbers.size() << "\n";

    return 0;
}

4. Deleting All Elements – clear()

The clear() method removes all elements from the vector, leaving it empty.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3};
    numbers.clear();
    
    std::cout << "Vector is empty: " << numbers.size() << "\n";

    return 0;
}

5. Accessing Elements – at()

The at() method allows access to an element with bounds checking.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {5, 10, 15};
    std::cout << numbers.at(1) << "\n"; // Accesses element at index 1

    return 0;
}

More Detailed Code Examples

To better understand the practical use of std::vector in C++, here are some examples showing declaration, initialization, and manipulation of vectors.

Declaration and Initialization of Vectors

Below is an example of basic vector declaration and initialization:

#include <iostream>
#include <vector>

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

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

In this example, the vector numbers is initialized with five elements and printed in a loop.

Adding and Removing Elements

Vectors allow dynamic addition and removal of elements using the push_back and pop_back methods:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);
    
    std::cout << "The vector contains: ";
    for (int number : numbers) {
        std::cout << number << " ";
    }
    
    numbers.pop_back(); // Removes the last element
    
    std::cout << "\nAfter pop_back: ";
    for (int number : numbers) {
        std::cout << number << " ";
    }

    return 0;
}

With this approach, we can easily add and remove elements from the vector without manually managing memory.

Iteration and Accessing Elements

We can use indexing or an iterator to traverse the vector:

#include <iostream>
#include <vector>

int main() {
    std::vector<std::string> names = {"Ana", "Marko", "Jovan"};

    for (size_t i = 0; i < names.size(); i++) {
        std::cout << names[i] << " ";
    }
    
    std::cout << "\nUsing iterator: ";
    for (auto it = names.begin(); it != names.end(); ++it) {
        std::cout << *it << " ";
    }
    
    return 0;
}

This approach demonstrates different ways to traverse a vector – using classic indexing and an iterator.

Conclusion

Vectors in C++ provide a flexible and efficient alternative to static arrays, offering dynamic allocation and useful methods for working with data. By understanding these basic operations, developers can efficiently manage arrays of data in their applications.

Advanced Features

Vectors in the C++ standard library offer a wide range of methods for data manipulation. This section covers advanced topics such as iteration, adding, and removing elements using push_back, insert, and erase, as well as the difference between size and capacity.

Iterating Through a Vector

There are multiple ways to iterate through a vector – using classic indexing, a range-based for loop, and iterators:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    std::cout << "Classic indexing: ";
    for (size_t i = 0; i < numbers.size(); i++) {
        std::cout << numbers[i] << " ";
    }

    std::cout << "\nRange-based for loop: ";
    for (int number : numbers) {
        std::cout << number << " ";
    }

    std::cout << "\nIterator: ";
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

Adding and Inserting Elements

Besides push_back, which adds an element to the end of the vector, we can use insert to insert elements at arbitrary positions.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30};

    numbers.push_back(40); // Adds 40 to the end
    numbers.insert(numbers.begin() + 1, 15); // Inserts 15 at the second position

    std::cout << "Vector after insertion: ";
    for (int number : numbers) {
        std::cout << number << " ";
    }

    return 0;
}

Removing Elements

The erase method is used to remove individual elements or a range of elements from a vector.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    numbers.erase(numbers.begin() + 2); // Removes the third element (30)
    numbers.erase(numbers.begin(), numbers.begin() + 2); // Removes the first two values

    std::cout << "Vector after removal: ";
    for (int number : numbers) {
        std::cout << number << " ";
    }

    return 0;
}

Difference Between size and capacity

The size() method returns the number of elements in the vector, while capacity() indicates how many elements can fit in the currently allocated space.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;

    std::cout << "Initial size: " << numbers.size() << ", capacity: " << numbers.capacity() << "\n";

    numbers.push_back(1);
    numbers.push_back(2);
    numbers.push_back(3);

    std::cout << "After adding elements: " << numbers.size() << ", capacity: " << numbers.capacity() << "\n";

    return 0;
}

Comparison with Other Containers

The C++ Standard Library offers multiple containers for data storage, with the most commonly used being std::vector, std::array, and std::list. Each of them has specific characteristics that make them suitable for particular situations.

Comparison of Key Features

Feature	std::vector	std::array	std::list
Size	Dynamic, can grow	Fixed, determined at creation	Dynamic
Access Speed	O(1) – direct access via indexing	O(1) – direct access via indexing	O(n) – the list must be traversed to reach the desired element
Adding/Removing Elements	Efficient at the end (O(1)), slow at the beginning and in the middle (O(n))	Not possible (fixed size)	Efficient anywhere (O(1)), but without direct access
Internal Structure	Memory array, elements are stored sequentially	Static array, elements are stored sequentially	Linked list, each element contains pointers to the next/previous

When to Use Which Container?

std::vector: When dynamic size and fast indexed access are needed.
std::array: When the array size is known and minimal overhead is required.
std::list: When frequent insertions or deletions at the beginning/middle of the structure are necessary.

Practical Examples

1. Using std::vector

std::vector is excellent when elements need to be dynamically added.


#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3};
    numbers.push_back(4); // Adds an element to the end
    std::cout << "Third element: " << numbers[2] << "\n"; // O(1) access

    return 0;
}

2. Using std::array

std::array is a static array that uses stack memory, making it faster when the size is known.


#include <iostream>
#include <array>

int main() {
    std::array<int, 3> numbers = {10, 20, 30};
    std::cout << "First element: " << numbers[0] << "\n"; // O(1) access

    return 0;
}

3. Using std::list

std::list is useful when frequent insertion or deletion at any position is needed.


#include <iostream>
#include <list>

int main() {
    std::list<int> numbers = {10, 20, 30};
    numbers.push_front(5); // Adds 5 to the beginning
    numbers.erase(numbers.begin()); // Removes the first element

    std::cout << "First element after removal: " << *numbers.begin() << "\n";

    return 0;
}

Conclusion

The choice between std::vector, std::array, and std::list depends on program needs. If fast element access and dynamic growth are required, std::vector is the best choice. If a fixed size with minimal memory overhead is needed, use std::array. If frequent additions and deletions from various positions are necessary, std::list is the better option.

Discussion on Efficiency and Usage

Vectors in C++ have many advantages compared to static arrays, especially when working with dynamic data. However, their usage comes with certain trade-offs. Below, the advantages and potential drawbacks of vectors are explained, along with examples for better understanding.

Advantages of Vectors

Feature	Description
Dynamic Size	Vectors automatically adjust their size based on the number of elements, unlike static arrays with a fixed size.
Ease of Use	Vectors come with built-in methods for adding, removing, and searching elements.
Safety	Methods like at() allow bounds checking, preventing access to non-existent elements.

Example: Dynamic Expansion

One of the biggest advantages of vectors is automatic expansion, which allows working with an unknown number of elements during program execution.


#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    for (int i = 1; i <= 10; ++i) {
        numbers.push_back(i); // Dynamically adds numbers from 1 to 10
    }

    for (int number : numbers) {
        std::cout << " " << number << " ";
    }

    return 0;
}

Disadvantages of Vectors

Feature	Description
Memory Preallocation	Vectors allocate extra memory to reduce reallocation frequency, which can lead to inefficient memory usage.
Performance	When a vector expands, reallocation of elements is required, which can be costly in terms of execution time.

Example: Reallocation Effect

When a vector expands, new memory is allocated, and existing elements are copied to the new location. This can cause performance degradation in cases of frequent element additions.


#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    for (int i = 1; i <= 100000; ++i) {
        numbers.push_back(i); // Frequent expansion due to element additions
    }

    std::cout << "Total number of elements: " << numbers.size() << "\n";

    return 0;
}

Conclusion

Vectors are ideal for scenarios where the size of data is variable, as they simplify working with dynamic structures. However, it is essential to consider their limitations, such as potential inefficiencies in memory usage and performance in cases of frequent expansions. In such situations, it may be better to consider other data structures, such as std::deque or std::list.

Advanced Topics

In addition to basic operations, vectors in C++ allow working with advanced concepts such as iterators, the difference between capacity and size, and working with 2D vectors (vectors of vectors). These topics are essential for advanced handling of dynamic data structures in more complex scenarios.

1. Iterators for Traversing a Vector

Iterators provide a flexible and efficient way to traverse vector elements, offering control over elements without directly using indices.


#include <iostream>
#include <vector>

int main() {
    std::vector<int> brojevi = {1, 2, 3, 4, 5};

    for (std::vector<int>::iterator it = brojevi.begin(); it != brojevi.end(); ++it) {
        std::cout << "Element: " << *it << "\n";
    }

    return 0;
}

Iterators are used with functions like begin() and end(), where *it accesses the value at the iterator's current position.

2. Difference Between Capacity and Size

Size (size()) represents the current number of elements in the vector, while capacity (capacity()) indicates how many elements the vector can hold before memory reallocation occurs.


#include <iostream>
#include <vector>

int main() {
    std::vector<int> brojevi;
    brojevi.push_back(10);
    brojevi.push_back(20);

    std::cout << "Size: " 
              << brojevi.size() 
              << ", Capacity: " 
              << brojevi.capacity() 
              << "\n";

    brojevi.reserve(100); // Reserves space for 100 elements
    std::cout << "Capacity after reserve: " 
              << brojevi.capacity() 
              << "\n";

    return 0;
}

Reserving capacity in advance can improve performance when a large number of additional elements is expected.

3. Working with 2D Vectors (Vectors of Vectors)

Vectors of vectors allow working with matrices or tabular data. Each element of the main vector can be another vector, creating a structure similar to a 2D array.


#include <iostream>
#include <vector>

int main() {
    std::vector<std::vector<int>> matrica = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    std::cout << "Element [0][1]: " 
              << matrica[0][1] 
              << "\n";

    for (int i = 0; i < matrica.size(); ++i) {
        for (int j = 0; j < matrica[i].size(); ++j) {
            std::cout << matrica[i][j] << " ";
        }
        std::cout << "\n";
    }

    return 0;
}

Vectors of vectors are more flexible than traditional 2D arrays, as each "row" can have a different number of columns.

Conclusion

These advanced topics provide significant flexibility when working with data in C++. Understanding iterators, the difference between capacity and size, and working with multidimensional structures allows for efficient use of vectors in more complex scenarios.

Practical Exercises

To better understand the use of vectors in C++, we suggest several simple exercises for practice. These exercises cover input and processing of vector elements, as well as the application of basic methods and loops.

1. Entering n numbers and printing them in reverse order

Task: Allow the user to enter n numbers into a vector and then print those numbers in reverse order.

#include <iostream>
#include <vector>

int main() {
    int n;
    std::cout << "Enter the number of elements: ";
    std::cin >> n;

    std::vector<int> brojevi(n);
    for (int i = 0; i < n; ++i) {
        std::cout << "Enter number " << i + 1 << ": ";
        std::cin >> brojevi[i];
    }

    std::cout << "Numbers in reverse order:\n";
    for (int i = n - 1; i >= 0; --i) {
        std::cout << brojevi[i] << " ";
    }
    std::cout << "\n";

    return 0;
}

2. Filtering even numbers from a vector

Task: Enter a sequence of numbers and extract all even numbers into a new vector.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> brojevi = {1, 2, 3, 4, 5, 6, 7, 8};
    std::vector<int> parni;

    for (int broj : brojevi) {
        if (broj % 2 == 0) {
            parni.push_back(broj);
        }
    }

    std::cout << "Even numbers:\n";
    for (int broj : parni) {
        std::cout << broj << " ";
    }
    std::cout << "\n";

    return 0;
}

3. Calculating the average of elements

Task: Enter a sequence of numbers and calculate their average.

#include <iostream>
#include <vector>

int main() {
    std::vector<int> brojevi = {10, 20, 30, 40, 50};
    int suma = 0;

    for (int broj : brojevi) {
        suma += broj;
    }

    double prosek = (double)suma / brojevi.size();
    std::cout << "Average: " << prosek << "\n";

    return 0;
}

Conclusion

These exercises provide practical examples for understanding basic vector operations, such as input, filtering, and aggregation. It is recommended to extend the exercises further for practice, for example, by adding input validation or working with larger data sets.

Adding Resources

To further expand your knowledge of vectors and their usage in C++, we recommend the following resources. These materials cover both basic and advanced topics, providing theoretical foundations and practical examples.

1. Official Documentation

The official documentation of the C++ standard library provides detailed information on all vector functions and methods, along with usage examples. It is recommended for precise and reliable information.

2. Online Courses

If you prefer an interactive learning approach, the following online courses provide in-depth lessons on working with vectors and other concepts in C++:

3. Relevant Books

Books on C++ programming often include extensive information on vectors. Here are some recommended titles for different knowledge levels:

"The C++ Programming Language" - Bjarne Stroustrup (creator of C++)
"Effective Modern C++" - Scott Meyers (an excellent guide to modern C++)
"C++ Primer" - Stanley B. Lippman, Josée Lajoie, Barbara E. Moo (a great book for beginners and intermediate learners)

4. Guides and Tutorials

The following tutorials and guides provide practical instructions and examples:

5. Discussions and Communities

Participating in communities and forums can help you solve specific problems and learn from others. Recommended communities:

Conclusion

Learning from various resources provides a broad spectrum of knowledge and helps in understanding how vectors are used in real-world projects. A combination of theory, practical exercises, and community engagement is recommended for a comprehensive grasp of this topic.

Previous
|< Introduction to arrays in C++

Next
Two dimensional array-matrix >|

VECTORS IN C++

Include header file: vector

Basic Manipulation of std::vector in C++

Vector methods in C++

Adding an element to the end of a vector

Vector size in c++

Taking the first element from a vector

​Retrieving the last element in a vector

Inserting a value at a specific position in a vector

Deleting the last element of the vector

​Deleting a vector element at a specific position

Deleting all vector elements in c++

Printing the elements of a vector

Test your code here!

Reading text data from standard input and inserting one by one into a vector

​Iterating through the elements of a vector using an iterator []

​Iterating through the elements of a vector using an iterator

Sorting vectors in c++ with the sort library function

Important std::vector Methods

Basic Methods

Examples of Method Usage

1. Adding Elements – push_back()

2. Removing Elements – pop_back()

3. Getting Size – size()

4. Deleting All Elements – clear()

5. Accessing Elements – at()

More Detailed Code Examples

Declaration and Initialization of Vectors

Adding and Removing Elements

Iteration and Accessing Elements

Conclusion

Advanced Features

Iterating Through a Vector

Adding and Inserting Elements

Removing Elements

Difference Between size and capacity

Comparison with Other Containers

Comparison of Key Features

When to Use Which Container?

Practical Examples

1. Using std::vector

2. Using std::array

3. Using std::list

Conclusion

Discussion on Efficiency and Usage

Advantages of Vectors

Example: Dynamic Expansion

Disadvantages of Vectors

Example: Reallocation Effect

Conclusion

Advanced Topics

1. Iterators for Traversing a Vector

2. Difference Between Capacity and Size

3. Working with 2D Vectors (Vectors of Vectors)

Conclusion

Practical Exercises

1. Entering n numbers and printing them in reverse order

2. Filtering even numbers from a vector

3. Calculating the average of elements

Conclusion

Adding Resources

1. Official Documentation

2. Online Courses

3. Relevant Books

4. Guides and Tutorials

5. Discussions and Communities

Conclusion

Cookie settings

Retrieving the last element in a vector

Deleting a vector element at a specific position

Iterating through the elements of a vector using an iterator []

Iterating through the elements of a vector using an iterator