Please convert this code to C$++$ template class:

#pragma once

#include

class Vector

$\{$

private:

size$\_$t size; $//$ "size$\_$t$"$ largest number you can creat in mem

size$\_$t capacity; $//$capacity is the size when you declare the array

int$*$ arr; $//$pointer

public:

Vector$()$ : arr$($nullptr$),$ size$(0),$ capacity$(0)\{\}$; $//$constructor

~Vector$()\{$

delete$[]$ arr; $//$how you delete an array

$\}//$destructor

$//$ paramaterized constructor

explicit Vector$($size$\_$t initialCapacity$)$ : arr$\{$ nullptr $\},$ capacity$\{$ initialCapacity $\}\{//$explicit$==$ one constructor

arr $=$ new int$[$capacity$]$; $//$created on the heap

$\}$

size$\_$t getSize$()$ const $\{//$const bc it wont change the state

return size;

$\}$

bool isEmpty$()$ const $\{$

return$($size $==0)$; $//$returns true if size$==0$

$\}$

int& operator$[]($size$\_$t index$)\{//$operator overloading

if $($index $>=$ size$)\{$

throw std::out$\_$of$\_$range$("$Index out of range."$)$;

$\}$

return arr$[$index$]$;

$\}$

$//$pushback function, you will have to create a new array because array size is set and copy, delete the old one, check if the array is full first

void push$\_$back$($int element$)\{$

if $($size $==$ capacity$)\{$

capacity $=($capacity $-0)?1$ : $2*$ capacity; $//$if condition is true, return one, otherwise return $2*$ capacity

int$*$ newArr $=$ new int$[$capacity$]$; $//$capacity $=$ new capacity

for $($size$\_$t i $=0$; i $<$ size; i$++)\{$

newArr$[$i$]=$ arr$[$i$]$;

$\}$

delete$[]$arr; $//$deletes old array

arr $=$ newArr;

$\}$

arr$[$size$]=$ element; $//$if array isn't full, this just adds the new element to the array and the size increases

size$++$;

$\}$

$//$insert function ie: insert$(2,100),$ if your array is full, create another array and double the size

$//$copy elements before the wanted index and add the new element then insert the rest of the old ones

$//$or move all the old ones forward if the array isn't full

void insert$($size$\_$t index, int value$)\{$

if $($size $==$ capacity$)\{//$increases size if full

capacity $=($capacity $-0)?1$ : $2*$ capacity; $//$if condition is true, return one, otherwise return $2*$ capacity

int$*$ newArr $=$ new int$[$capacity$]$;

for $($size$\_$t i $=0$; i $<$ index; i$++)\{$

newArr$[$i$]=$ arr$[$i$]$;

$\}$

newArr$[$index$]=$ value; $//$inserts value

for $($size$\_$t i $=$ index; i $<$ size; i$++)\{$

newArr$[$i $+1]=$ arr$[$i$]$;

$\}$

delete$[]$ arr;

arr $=$ newArr;

size$++$;

$\}$

else $\{//$if array isnt full, shifts elements after index

for $($size$\_$t i $=0$; i $>$ index; $--$i$)\{$

arr$[$i$]=$ arr$[$i $-1]$;

$\}$

arr$[$index$]=$ value;

size$++$;

$\}$

$\}$

$//$popback

void popBack$()\{$

if $($size $>0)\{$

size$--$; $//$removes last element and decreases size

$\}$

$\}$

$//$erases an element at a specific position

$//$create a new array and exclude the index of the value

$//$delete old array

void erase$($size$\_$t index$)\{$

int$*$ newArr;

for $($size$\_$t i $=0$; i $<$ size; i$++)\{//$goes through the whole array

if $($i $!=$ arr$[$index$])//$if not equal to given index, copies it to the new array

newArr$[$i$]=$ arr$[$i$]$;

$\}$

delete$[]$ arr; $//$deletes old array

arr $=$ newArr; $//$sets new array to array

size$--$; $//$decreases size

$\}$

$//$operator$[]$: get the element at a specific index

int getIndexElement$($size$\_$t index$)\{$

return arr$[$index$]$;

$\}$

$//$return size of array$---$ already done at line $24$

$\}$;