What is vector in c plus plus definition?

Answer 1

A vector is a class template that encapsulates a dynamic array along with its current size, treating both as a single entity. Since the allocated memory and its size are kept in sync internally by the vector, there is no need to manually keep track of the array size or the memory allocation as you would with a C-style array. This makes it much easier to work with arrays in C++.

To understand the difference, consider the following:

#include<iostream>

#include<vector>

int main()

{

unsigned int i;

std::cout<<"C-style array:\n"<<std::endl;

unsigned int size=10;

int* a=(int*)malloc(size*sizeof(int));

for(i=0; i<size; ++i)

a[i]=i*2;

++size;

a = (int*)realloc(a,size*sizeof(int));

a[size-1]=42;

for(i=0; i<size; ++i)

std::cout<<a[i]<<std::endl;

free(a);

a=NULL;

std::cout<<"\nC++ vector:\n"<<std::endl;

std::vector<int> v (10);

for(i=0; i<v.size(); ++i)

v[i]=i*2;

v.push_back(42);

for(i=0; i<v.size(); ++i)

std::cout<<v[i]<<std::endl;

}

With the C-style array, we must keep track of the size separately from the array. Thus when we reallocate to accommodate the new element (42), we must increase the size accordingly. The equivalent C++ code is much simpler because the size is updated internally by the vector itself, and we don't need to worry about the memory allocation. When the vector falls from scope, the memory is freed automatically. Note how we can use the subscript operator [] to access the individual elements of the vector just as we would with a C-style array.

As well as encapsulating the array and its size as a single entity, vectors provide member methods to make it easier to work with the array. In the above example we used the vector::push_back method to add the new element (42) to the end of the array. We can also extract elements from the end of the array using the vector::pop_back() method. Thus a vector can emulate a stack structure (last-in, first-out). However, keep in mind that just as arrays are unsuitable for stacks due to the reallocations required to keep the memory contiguous, the same is true of vectors. the reallocations may be hidden from you but they still occur in the background. However, anywhere you would normally use a dynamic array, a vector can be used instead.

Another advantage of vectors over arrays is when passing arrays to functions. Normally, the function will expect a reference to the array along with the number of elements in the array. Since vectors encapsulate the size you need only pass a reference to the vector itself. Although you could overload the function to accept either a vector or an array, given the simpler nature of a vector it is better to avoid dynamic arrays altogether. Static arrays are usually fine for small allocations on the stack, but you can also use vectors for larger static arrays on the heap. The array is actually dynamic, of course, but if you don't change the size then it is effectively static. The only real difference is that the allocation is on the heap rather than the stack.