以下是完整的源代码，从您的源代码更新：

#pragma once

//using namespace std;

template <class T>
class  Vector
{
public:

    typedef T * iterator;

    Vector();
    Vector(unsigned int size);
    Vector(unsigned int size, const T & initial);
    Vector(const Vector<T> & v);      
    ~Vector();

    unsigned int capacity() const;
    unsigned int size() const;
    bool empty() const;
    iterator begin();
    iterator end();
    T & front();
    T & back();
    void push_back(const T & value); 
    void pop_back();  

    void reserve(unsigned int capacity);   
    void resize(unsigned int size);   

    T & operator[](unsigned int index);  
    Vector<T> & operator=(const Vector<T> &);
    void clear();
private:
    unsigned int my_size;
    unsigned int my_capacity;
    T * buffer;
};

// Your code goes here ...
template<class T>
Vector<T>::Vector()
{
    my_capacity = 0;
    my_size = 0;
    buffer = 0;
}

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T[my_size];  
    for (unsigned int i = 0; i < my_size; i++)
        buffer[i] = v.buffer[i];  
}

template<class T>
Vector<T>::Vector(unsigned int size)
{
    my_capacity = size;
    my_size = size;
    buffer = new T[size];
}

template<class T>
Vector<T>::Vector(unsigned int size, const T & initial)
{
    my_size = size;
    my_capacity = size;
    buffer = new T [size];
    for (unsigned int i = 0; i < size; i++)
        buffer[i] = initial;
    //T();
}

template<class T>
Vector<T> & Vector<T>::operator = (const Vector<T> & v)
{
    delete[ ] buffer;
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T [my_size];
    for (unsigned int i = 0; i < my_size; i++)
        buffer[i] = v.buffer[i];
    return *this;
}

template<class T>
typename Vector<T>::iterator Vector<T>::begin()
{
    return buffer;
}

template<class T>
typename Vector<T>::iterator Vector<T>::end()
{
    return buffer + size();
}

template<class T>
T& Vector<T>::front()
{
    return buffer[0];
}

template<class T>
T& Vector<T>::back()
{
    return buffer[my_size - 1];
}

template<class T>
void Vector<T>::push_back(const T & v)
{
    if (my_size >= my_capacity)
        reserve(my_capacity +5);
    buffer [my_size++] = v;
}

template<class T>
void Vector<T>::pop_back()
{
    my_size--;
}

template<class T>
void Vector<T>::reserve(unsigned int capacity)
{
    if(buffer == 0)
    {
        my_size = 0;
        my_capacity = 0;
    }    
    T * Newbuffer = new T [capacity];
    //assert(Newbuffer);
    unsigned int l_Size = capacity < my_size ? capacity : my_size;
    //copy (buffer, buffer + l_Size, Newbuffer);

    for (unsigned int i = 0; i < l_Size; i++)
        Newbuffer[i] = buffer[i];

    my_capacity = capacity;
    delete[] buffer;
    buffer = Newbuffer;
}

template<class T>
unsigned int Vector<T>::size()const//
{
    return my_size;
}

template<class T>
void Vector<T>::resize(unsigned int size)
{
    reserve(size);
    my_size = size;
}

template<class T>
T& Vector<T>::operator[](unsigned int index)
{
    return buffer[index];
}  

template<class T>
unsigned int Vector<T>::capacity()const
{
    return my_capacity;
}

template<class T>
Vector<T>::~Vector()
{
    delete[ ] buffer;
}
template <class T>
void Vector<T>::clear()
{
    my_capacity = 0;
    my_size = 0;
    buffer = 0;
}

也许是这个错字？

Vector<T>::Vector(unsigned int size, const T & initial)
{
    my_size-size;

你的“储备”被打破了。为本地缓冲区使用另一个变量名。

除了需要修复reserve函数之外，复制构造函数和复制赋值运算符还有一个有趣的问题：

Vector<T> t1 = t2;

这将设置t1的容量等于t2的容量（变量），但是t1的实际容量将是t2的大小;因此，当您在复制构造函数/赋值操作符之后开始将元素推送到向量上时，您将遇到缓冲区溢出问题。
你需要把它改成

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_capacity;
    buffer = new T[my_capacity];
    memcpy(buffer, v.buffer, my_size * sizeof(T));  
}

OR（如果您希望允许它调整大小为更小的数组）

template<class T>
Vector<T>::Vector(const Vector<T> & v)
{
    my_size = v.my_size;
    my_capacity = v.my_size;
    buffer = new T[my_size];
    memcpy(buffer, v.buffer, my_size * sizeof(T));  
}

这段代码没有为我编译。Clang抱怨说114行（back（）的实现）期望调用“size”。
我认为这一行的本意是“返回缓冲区[size（）-1];”
它还给出了有关此构造函数实现的警告：template Vector：：Vector（unsigned int size，const T & initial）
第一行应该是“my_size = size;“（这个构造函数的）最后一行可能应该被删除。
接下来，它在第209行的Assert失败：return（v3.size（））;
这打开了相当多的蠕虫，但明显的问题是resize（）行：“size = size;这可能意味着“my_size = size;”
有了这个变化，我们现在在第121行崩溃，这是在push_back（）中从第231行调用的“v6.push_back（100）;”
由于reserve（）中的问题，此操作失败。我们正在创建一个局部变量“buffer”，其名称与成员变量相同。让我们将名称更改为temp_buffer。注意：不要assert（）运行时错误。assert（）用于逻辑错误。这个assert（）不能失败。new永远不会返回0。它会扔的。
在reserve（）中做了明显的修复之后（还有其他问题），我们现在在reserve（）中的copy（）中崩溃了，在main（）中的lin 3 208调用resize（），“v3.resize（1）;“.
我们看到，当我们减少容量时，reserve实际上是在分配一个新的缓冲区。这既是性能的损失，也是可靠性的损失（内存分配可能失败）。但是我们仍然不应该崩溃，所以我们将尝试在不解决明显的设计缺陷的情况下防止崩溃。
崩溃即将到来，因为我们正在将容器中存在的所有项复制到新分配的数组中。如果我们只在需要增加容量时才这样做，那么这是正确的，但是在这种情况下，我们的项目超过了新容量所能容纳的项目。如果my_size大于该值，则代码应将其设置为新容量。
现在测试代码报告“SUCCESS”。
然而，这段代码仍然存在许多问题。
最大的问题之一是我们没有在分配的数组中使用未初始化的内存。这样做是std：：vector标准所要求的，它具有性能和可靠性优势。但它也使代码复杂化，所以这可能是我们可以接受的捷径，因为这显然是一种智力练习。
施工单位：使用初始化器语法初始化数据成员。
使用复制构造函数和初始值构造函数，如果任何循环赋值引发异常，则会泄漏已分配的数组。
赋值操作符应该分配一个大小为“my_capacity”而不是“my_size”的新缓冲区，尽管有一个明显的优化，如果右边对象的大小不大于“this”对象，我们根本不应该分配。
如果在赋值操作符中分配新数组失败，我们已经删除了缓冲区，所以我们最终（当我们的Vector对象被销毁时）会有一个缓冲区的双重删除，在此之前我们可能会有所有的麻烦。
在push_back（）中，为了支持标准的性能保证，我们需要将容量增加现有容量大小的某个常数。例如：“reserve（my_capacity * 1.5）;”