Implement Own Vector Class in C++
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].