Copy-assignment in a custom vector - c++

Question

I am working on a custom vector (String_vector) based off of a custom string class (String). I am having trouble with my copy assignment, and I think I am in some sort of loop that doesn't terminate. In my implementation I return *this as shown here, where I implement the copy-and-swap method.
String class:
class String{
public:
int len;
char *str;
String()
:len(0), str(nullptr){}
String(char const* S)
:len(strlen(S)), str(new char[len +1]){
assert(S != 0);
strcpy(str, S);
}
~String(){
delete[]str;
}
};
String_vector class:
class String_vector{
public:
String_vector(std::initializer_list<String>);
String* base = nullptr;
String* last = nullptr;
String* limit = nullptr;
String_vector(){};
String_vector(const String_vector& v){
reserve(v.size());
base = last;
last = uninitialized_copy(v.base, v.last, base);
}
//I think the issue is somewhere in here
String_vector& operator=(const String_vector & v){
String_vector p = v;
swap(*this, p);
return *this;
}
~String_vector(){
clear();
deallocate(base);
}
void clear(){
while(last > base){
(--last)->~String();
}
}
size_t size()const{
return last - base;
}
void swap(String_vector & v1, String_vector & v2){
std::swap(v1.base, v2.base);
std::swap(v1.last, v2.limit);
std::swap(v1.limit, v2.limit);
}
void reserve(std::size_t n){
if(!base){
base = allocate<String>(n);
last = base;
limit = n + base;
}else{
String* p = allocate<String>(n);
String* q = p;
for(String*i = base; i != last; ++i){
new(q)String(*i);
++q;
}
for(String*i = base; (i=last); ++i){
i ->~String();
}
deallocate<String>(base);
base = p;
last = q;
limit = base + n;
}
}
template<typename T>
inline T*
allocate(int n)
{
return reinterpret_cast<T*>(::operator new(n * sizeof(T)));
}
template<typename T>
inline void
deallocate(T* p)
{
::operator delete(p);
}
template<typename T, typename... Args>
inline T*
construct(T* p, Args&&... args)
{
return new (p) T(std::forward<Args>(args)...);
}
template<typename T>
inline void
destroy(T* p)
{
p->~T();
}
template<typename T>
inline T*
uninitialized_copy(T const* first, T const* last, T* out)
{
while (first != last) {
construct(out, *first);
++out;
++first;
}
return out;
}
size_t capacity()const{
return limit - base;
}
void push_back(String const & s){
if(!base){
reserve(8);
}else if(last == limit){
reserve(2*capacity());
}
construct(last++, s);
}
};
String_vector::String_vector(std::initializer_list<String> list)
: base(), last(), limit()
{
reserve(list.size());
for (String const& s : list)
push_back(s);
}
and main:
int main()
{
String_vector v1 {"a", "b", "c"};
String_vector v2;
v2 = v1;
return 0;
}
Thanks!