Implement Own Vector Class in C++ I am preparing for an interview and came to know about this question: implement a vector class in C++. I thought of how I would write it an interview and included the code below. The things I know I did not cover already are:
1) No use of templates for different data types
2) No use of iterators for iterating.
My point is I wanted to write a simple code and I want to know if that would be sufficient to crack the interview round or not?
Can you please go through the below code and point out the things that I must cover from an interview perspective. Thanks.

class Vector{
        int capacity;
        int sizet;
        int *arr;
    public:
        Vector():capacity(0),sizet(0),arr(new int){}
        Vector(int size):capacity(size),sizet(size),arr(new int[sizet]()){}
        Vector(const Vector &amp;v){            //copy ctor 
                capacity = v.capacity;
                sizet = v.sizet;
                arr = new int[sizet];
            for(int i=0;i&lt;sizet;i++)
                arr[i] = v.arr[i];

        }
        int &amp;operator [](int index){            //overloading index[] operator
            return arr[index];
        }
        Vector &amp;operator==(const Vector&amp; v){        //overloading assignment operator
        if(this != v){
                capacity = v.capacity;
                sizet = v.sizet;
                arr = new int[sizet];
            for(int i=0;i&lt;sizet;i++)
                arr[i] = v.arr[i];
            }
            return *this;
        }
        void push_back(int elem){
            if(sizet == capacity){
                if(capacity ==0)
                    capacity++;
                else
                    capacity = 2*capacity;
            }
            arr[sizet++]=elem;
        }
        void pop_back(){
            sizet--;
        }
        void insert(iterator it,int size=1,int val=0){

        }
        int size(){
            return sizet;
        }
        void resize(int n){
        if(sizet &lt; n){                  //if increasing the size
            for(int i=sizet;i&lt;n;i++)
                arr[sizet++]=0;
        }
        else                            //decreasing the size
            sizet = n;
        }
        int at(int index){
            return arr[index];
        }
        int front(){
            return arr[0];
        }
        int back(){
            return arr[sizet];
        }

        ~Vector(){              //dtor
        delete arr[];
        }
    };


Edit: Resolved the naming conflict as was suggested.
You tagged c++11, but your code does not look like C++11. You do not implement move construction and move assignment. You should implement them. Here's a sample implementation using the copy-and-swap idiom.

friend void swap(Vector&amp; a, Vector&amp; b)
{
    using std::swap;
    swap(a.capacity, b.capacity);
    swap(a.sizet, b.sizet);
    swap(a.arr, b.arr);
}

Vector(Vector&amp;&amp; v)
    :Vector{}
{
    swap(*this, v);
}

Vector&amp; operator=(Vector v)
{
    swap(*this, v);
    return *this;
}


This way, you don't have to define a separate copy assignment operator.
Your default constructor sets arr to new int. This makes no sense and cannot be handled by the destructor. You should set arr to nullptr.
Use ++i, not i++, in discarded-result expressions. See Difference between i++ and ++i in a loop?.
Consider using standard algorithms instead of hand-crafted loops when plausible. For example:

for (int i = 0; i &lt; sizet; i++)
    arr[i] = v.arr[i];
}


Can be replaced by

std::copy_n(v.arr, sizet, arr);


You will need to #include &lt;algorithm&gt; for this to work.
Your copy constructor uses assignment instead of member initializer clauses. You should use member initializer clauses uniformly. Now your copy constructor should look like this:

Vector(const Vector&amp; v)
    :capacity{v.capacity},
     sizet{v.sizet},
     arr{new int[v.sizet]} // to avoid dependence on member declaration order
{
    std::copy(v.arr, v.arr + sizet, arr);
}

Where is the const overload for operator[], at, front, and back?
Your push_back is incorrect. It does not allocate any memory. You will get an out-of-range error when capacity exceeds the actual capacity. Same applies to resize.
size() should be const.
Your at does the same job as operator[]. at should check for out-of-range errors and raise an exception if index &gt;= sizet.
front and back should return a reference instead of a value.
The implementation of back is wrong. It should return arr[sizet - 1].