Create own implementation of vector which has moving operations and push_back for rvalue template&lt;typename T&gt;
class Vector
{
private:
    size_t size;
    size_t capacity;
    T* buffer;
public:
    Vector(size_t s) {
        size = 0;
        capacity = s;       
        buffer = new T[capacity];
    }
    //Move constructor
    Vector(Vector&amp;&amp; rhs): size(rhs.size),
                          capacity(rhs.capacity),
                          buffer(tmp.buffer)
    {
        rhs.buffer = nullptr;
    }
    T&amp; operator=(Vector&amp;&amp; tmp) {
        size = tmp.size;
        capacity = tmp.capacity;
        buffer = std::move(tmp.buffer);
        return *this;
    }
    void push_back(const T&amp; v) {
        if (size &gt;= capacity)
            reserve(capacity + 5);
        buffer[size++] = v;
    }
    void push_back(T&amp;&amp; v) {
        if (size &gt;= capacity)
            reserve(capacity + 5);
        buffer[size++] = v;
    }


Have I implemented all move operations in my class Vector?
Is it correct implementation of method push_back for rvalue ?
Have I implemented all move operations in my class Vector? 


Yes. And no. You have a bug. You are not resetting the size of the moved Vector, but resetting its buffer, which can break code like this:

Vector&lt;int&gt; vec;
vec.push_back(1);
Vector&lt;int&gt; v = std::move(vec);
if (vec.size() == 1)
    vec[0] = 8; // undefined behavior!


Also, what is tmp? Did you mean to use rhs?


  Is it correct implementation of method push_back for rvalue ?


No. In

buffer[size++] = v;


you are not taking advantage that v is a rvalue reference. You are copying v into the buffer, but that is not needed, as v points to a rvalue. You can move it to the buffer:

buffer[size++] = std::move(v);




Although you have implemented all move operations for Vector, you forgot the copy operations. But maybe you just hide them because you didn't want any feedback on them.

Nonetheless, you could have written your move constructor like this, which is more readable IMO (and doesn't include the bug mentioned above):

Vector(Vector&amp;&amp; rhs) : size(std::exchange(rhs.size, 0)),
                       capacity(std::exchange(rhs.capacity, 0)),
                       buffer(std::echange(rhs.buffer, nullptr))
{}


You can do the same thing for operator=(Vector&amp;&amp;).

However, consider using the copy-swap idiom, for a exception safe way of implementing the Rule of Five.