Advantages of vector over array in C++
We have already discussed arrays and vectors. In this post, we will discuss advantages of vector over normal array. Advantages of Vector over arrays :
CPP
#include <bits/stdc++.h> using namespace std; int main() { int array[100]; // Static Implementation int * arr = new int [100]; // Dynamic Implementation vector< int > v; // Vector's Implementation return 0; } |
Size of arrays are fixed whereas the vectors are resizable i.e they can grow and shrink as vectors are allocated on heap memory.
CPP
#include <bits/stdc++.h> using namespace std; int main() { int array[100]; // Static Implementation cout << "Size of Array " << sizeof (array) / sizeof (array[0]) << "\n" ; vector< int > v; // Vector Implementation // Inserting Values in Vector v.push_back(1); v.push_back(2); v.push_back(3); v.push_back(4); v.push_back(5); cout << "Size of vector Before Removal=" << v.size() << "\n" ; // Output Values of vector for ( auto it : v) cout << it << " " ; v.erase(v.begin() + 2); // Remove 3rd element cout << "\nSize of vector After removal=" << v.size() << "\n" ; // Output Values of vector for ( auto it : v) cout << it << " " ; return 0; } |
Size of Array 100 Size of vector Before Removal=5 1 2 3 4 5 Size of vector After removal=4 1 2 4 5
Arrays have to be deallocated explicitly if defined dynamically whereas vectors are automatically de-allocated from heap memory.
CPP
#include <bits/stdc++.h> using namespace std; int main() { int * arr = new int [100]; // Dynamic Implementation delete [] arr; // array Explicitly deallocated vector< int > v; // Automatic deallocation when variable goes out of scope return 0; } |
Size of array cannot be determined if dynamically allocated whereas Size of the vector can be determined in O(1) time.
When arrays are passed to a function, a separate parameter for size is also passed whereas in case of passing a vector to a function, there is no such need as vector maintains variables which keeps track of size of container at all times.
CPP
#include <bits/stdc++.h> using namespace std; int main() { int * arr = new int [100]; // Dynamic Implementation cout << "Size of array= " ; cout << sizeof (arr) / sizeof (*arr) << "\n" ; // Pointer cannot be used to get size of // block pointed by it return 0; } |
Size of array= 2
When array becomes full and new elements are inserted; no reallocation is done implicitly whereas When vector becomes larger than its capacity, reallocation is done implicitly.
Arrays cannot be returned unless dynamically allocated from a function whereas vectors can be returned from a function.
CPP
// Program to demonstrate arrays cannot be returned #include <bits/stdc++.h> using namespace std; int * getValues() { int arr[10]; // Array defined locally for ( int i = 0; i < 10; i++) // Putting Values in array arr[i] = i + 1; return arr; // returning pointer to array } // main function int main() { int * array; // pointer of int type array = getValues(); // Call function to get arr for ( int i = 0; i < 10; i++) { // Printing Values cout << "*(array + " << i << ") : " ; cout << *(array + i) << endl; } return 0; } |
Output:
warning: address of local variable 'arr' returned [-Wreturn-local-addr] Segmentation Fault (SIGSEGV)
CPP
// Program to demonstrate vector can be returned #include <bits/stdc++.h> using namespace std; // Function returning vector vector< int > getValues() { vector< int > v; // Vector defined locally for ( int i = 0; i < 10; i++) // Inserting values in Vector v.push_back(i + 1); return v; // returning pointer to array } // main function int main() { vector< int > get; get = getValues(); // Call function to get v // Output Values of vector for ( auto it : get) cout << it << " " ; return 0; } |
1 2 3 4 5 6 7 8 9 10
Arrays cannot be copied or assigned directly whereas Vectors can be copied or assigned directly.
CPP
#include <bits/stdc++.h> using namespace std; // main function int main() { vector< int > v; // Vector defined locally for ( int i = 0; i < 10; i++) v.push_back(i + 1); vector< int > get; get = v; // Copying vector v into vector get cout << "vector get:\n" ; for ( auto it : get) cout << it << " " ; int arr[10]; for ( int i = 0; i < 10; i++) // Putting Values in array arr[i] = i + 1; int copyArr[10]; copyArr = arr; // Error return 0; } |
Output:
vector get: 1 2 3 4 5 6 7 8 9 10 error: invalid array assignment copyArr=arr;
Following are the list of advantages of vector over array:
- Resizing: Vectors can dynamically resize themselves, while arrays have a fixed size.
- Memory allocation: Vectors handle memory allocation and deallocation automatically, while arrays require manual management.
- Element access: Vectors provide direct access to elements using an iterator, while arrays require using an index.
- Sorting: Vectors provide built-in sorting functions, while arrays require manual sorting.
- Insertion and deletion: Vectors provide efficient insertions and deletions at the end, while arrays require shifting of elements.
- STL compatibility: Vectors are a part of the Standard Template Library (STL) and are compatible with other STL functions and algorithms.
- Exception handling: Vectors have built-in exception handling for out-of-bounds access, while arrays do not.
- Standardization: Vectors are a standardized feature of modern programming languages, and therefore more widely supported
- Memory utilization: Vector can save memory space if the number of elements increases after the array created by using dynamic memory allocation.
- Iterators: Vectors provide iterators that make it easy to traverse the elements, whereas arrays require manual pointer manipulation.
- Better cache performance: Vectors allow for better cache performance.
- Simplified code: Using vectors instead of arrays can simplify the code as it eliminates the need for manual memory management.
- Highly expressive: Vectors are more expressive and easy to understand than arrays, as they have names and provide more useful methods.
- Exception safety: Vectors provide exception safety, which means that they are less likely to cause errors and crashes.
Contact Us