Any element can be changed at any place, which is the same as accessing them. The same way that it was done with arrays, any element at any given place may be accessed by its index number.

vector<int> v = {1, 2, 3, 4};
cout << "Element at index 0 is " << v[0] << endl;

Output:

Element at index 0 is 1

The at() method, which accepts the index number as an argument and returns the element at that place, is another method that gets added for vectors.

vector<int> v = {1, 2, 3, 4};
cout << "Element at index 2 is " << v.at(2) << endl;

Output:

Element at index 2 is 3

F. Element removal from a vector

A vector’s elements can be removed in a variety of methods. When we use the pop back method to remove an element from the tail of a vector, we do so in the most cost-effective way possible. The element is popped from the back using the pop back() function, which requires no parameters.

#include <iostream>
#include <vector>
using namespace std;
 
void display(vector<int> v)
{
    cout << "The elements are: ";
    for (auto it : v)
    {
        cout << it << " ";
    }
    cout << endl;
}
 
int main()
{
    vector<int> v = {1, 2, 3, 4};
    display(v);
    v.pop_back(); //4 gets popped from the back
    display(v);
}

Output:

The elements are: 1 2 3 4 
The elements are: 1 2 3

Another method to remove an element allows us to remove it from any random position. Here, we use the erase() method. The syntax for using the erase method is

vector_name.erase(iterator);

The iterator in this case is a pointer to the location where the element is popped. Here’s an illustration of how to utilise the wipe() method:

#include <iostream>
#include <vector>
using namespace std;
 
void display(vector<int> v)
{
    cout << "The elements are: ";
    for (auto it : v)
    {
        cout << it << " ";
    }
    cout << endl;
}
 
int main()
{
    vector<int> v = {1, 2, 3, 4};
    display(v);
    v.erase(v.begin()); 
    display(v);
}

Output:

The elements are: 1 2 3 4 
The elements are: 2 3 4

The post C++ Vectors-Part II first appeared on Student Projects.

Sequence containers known as vectors are categorised as class templates. They are employed to store data in a linear manner. A vector can hold objects of a single data type. With contrast to arrays, we can access elements more quickly in vectors. However, insertion and deletion at any other location besides the end is considerably slower. Additionally, adding any piece at the end goes more quickly.

B. Implementing vectors in our programmes

The header file vector> must be present for our code to be able to use vectors. And a vector is defined using the syntax

vector<data_type> vector_name;

Any data type could be used in place of data type. One advantage of utilising vectors is that unlike arrays, which require a size parameter, vectors allow us to insert as many elements as we like.

The push back method is the first of several ways provided by vectors to access and use their constituent parts. Visit this website, std::vector – C++ Reference, to access all the methods and member functions in detail.

C. Initializing a vector

There are various ways to initialise a vector:

A vector could be initialised using the first technique by having all of its items entered at the time the vector is defined.

vector<int> v = {1, 2, 3, 4};

Another way to initialise a vector is to pass it’s definition along with two parameters, the first of which specifies the vector’s size and the second of which specifies the uniform value the vector will have throughout all of its locations.

vector<int> v(4, 10);

Here, v is of size 4 with value 10 at all positions.

D. Adding components to a vector

A vector can have elements added to it in a variety of ways. When we use the push back method, the most cost-effective way to insert an element into a vector is at the tail. The elements that are to be inserted are passed as an argument to the push back() function, which pushes the element to the back.

#include <iostream>
#include <vector>
using namespace std;
 
void display(vector<int> v)
{
    cout << "The elements are: ";
    for (auto it : v)
    {
        cout << it << " ";
    }
    cout << endl;
}
 
int main()
{
    vector<int> v = {1, 2, 3, 4};
    display(v);
    v.push_back(5); //5 is inserted at the back
    display(v);
}

Output:

The elements are: 1 2 3 4 
The elements are: 1 2 3 4 5

The post Vectors in C++-Part -I first appeared on Student Projects.

Vectors are implemented as arrays that can grow and shrink in size, with all elements stored in contiguous memory. This makes vectors ideal for applications that require fast random access to elements, such as games and simulations. The size of a vector can be easily changed by using the push_back method to add elements to the end of the vector, or the pop_back method to remove elements from the end of the vector.

One of the key benefits of vectors is their ease of use. They can be used like arrays, but with the added benefits of dynamic sizing and automatic memory management. For example, to declare a vector of integers, you simply write:

vector<int> v;

Elements can be easily added to a vector using the push_back method:

v.push_back(10);
v.push_back(20);

And elements can be accessed using the array-style square bracket operator:

cout << v[0] << endl; // Outputs 10
cout << v[1] << endl; // Outputs 20

Vectors are also compatible with the algorithms and functions provided by the STL, making it easy to perform operations such as sorting, searching, and transforming the elements of a vector. For example, to sort a vector of integers, you can use the sort algorithm:

sort(v.begin(), v.end());

In addition to its ease of use, vectors are also highly efficient, with constant-time access to elements and amortized constant-time insertion and deletion at the end of the vector. This makes vectors ideal for use in performance-critical applications, such as games and simulations.

One important aspect to consider when using vectors is their memory management. Because vectors store elements in contiguous memory, resizing a vector can result in reallocating the entire vector, which can be time-consuming. To avoid this, it is recommended to reserve a suitable amount of memory for a vector before inserting elements, using the reserve method:

v.reserve(100);

In conclusion, the vector is a versatile and powerful container in the STL of C++, offering ease of use, efficiency, and compatibility with the algorithms and functions provided by the STL. Whether you are writing a simple program or a complex simulation, vectors are a valuable tool for storing and manipulating collections of elements in C++.

The post C++ Vectors first appeared on Student Projects.