Resizing a List, I get segmentation fault - c++

Question

I have implemented a List (different from standard c++ list), this is for exercise.
The problema is that after resizing the list, I get segmentation fault.
I have marked the linke when I get seg. fault, I don't know the reason.
The purpose of resize method is to resize the list: let's say that I have a list of 2 integers, if I resize it to 5 I'll get other 3 elements, all initialized to zero.
If instead I have a list of 4 elements, and I resize it to 2, 2 elelements will be cut.
If I have a int list l, l[0] is the first object of the list, l[1] the second...
So I crash when i attempt to resize the list, exactly in the line that I have marked.
#include <iostream>
#include <cassert>
using namespace std;
template<class T>
class List
{
public:
List<T>();
~List<T>();
protected:
List<T> (T info);
public:
int size();
void resize(int length);
void add(T info,int i);
void push(T info);
T pop();
void remove(int i);
T extract(int i);
T get(int i);
friend ostream& operator<< (ostream& out, List<T>& l)
{
List<T>* ptr=l.next;
if(l.info==NULL)
{
while(ptr!=&l)
{
out << *(ptr->info) << "\t";
ptr=ptr->next;
}
}
else
{
out<< *(l.info) <<"\t";
}
return out;
}
friend istream& operator>> (istream& in,List<T>& l)
{
in >> (*l.info);
return in;
}
bool operator== (List<T>& r)
{
bool result=true;
List<T>* p1,*p2;
p1=this;
p2=&r;
assert((p1->info==NULL && p2->info==NULL)||(p1->info!=NULL && p2->info!=NULL));
if(p1->info==NULL)
{
p1=p1->next;
p2=p2->next;
result=(p1->length == p2->length);
while(result && p1!=this)
{
result=(*(p1->info)==*(p2->info));
p1=p1->next;
p2=p2->next;
}
}
else
{
result=(*(p1->info)==*(p2->info));
}
return result;
}
List<T>& operator+= (List<T>& l)
{
List<T>* ptr;
ptr=l.next;
while(ptr!=&l)
{
this->push(*(ptr->info));
ptr=ptr->next;
}
return *this;
}
List<T>& operator[] (int i)
{
List<T>* ptr;
ptr=this;
assert(i<length);
for(int j=0;j<=i;j++)
ptr=ptr->next;
return *ptr;
}
private:
T *info;
List <T>* next;
List <T>* prev;
int length;
};
template <class T>
List<T>::List ()
{
info=NULL;
next=this;
prev=this;
length=0;
}
template<class T>
List<T>::List (T info)
{
next=this;
prev=this;
this->info=new T();
*(this->info)=info;
}
template<class T>
List<T>::~List()
{
List<T>* ptr, * temp;
ptr=this->next;
if(this->info==NULL)
{
while(ptr!=this)
{
delete ptr->info;
temp=ptr;
ptr=ptr->next;
delete temp;
}
}
}
template<class T>
int List<T>::size()
{
return length;
}
template<class T>
void List<T>::resize(int length)
{
assert(length>=0);
if(this->length<length)
{
for(int i=this->length;i<length;i++)
push(0);
}
else
{
for(int i=length;i<this->length;i++)
extract(this->length-1); // here I call exctract, extract calls
} // remove, remove calls get
}
template<class T>
void List<T>::add(T info,int i)
{
List<T>* ptr,*t1,*t2;
length++;
ptr=&((*this)[i]);
t1=ptr->prev;
t2=ptr;
ptr=new List<T>(info);
t1->next=ptr;
ptr->prev=t1;
t2->prev=ptr;
ptr->next=t2;
}
template<class T>
void List<T>::push(T info)
{
add(info,length-1);
}
template<class T>
void List<T>::remove(int i)
{
List<T>* ptr,*t1,*t2;
ptr=&((*this)[i]);
t1=ptr->prev;
t2=ptr->next;
delete ptr;
t1->next=t2;
t2->prev=t1;
length--;
}
template<class T>
T List<T>::extract(int i)
{
T temp=this->get(i);
remove(i);
return temp;
}
template<class T>
T List<T>::get(int i)
{
assert(i<length);
return *(this[i].info); // here i have seg. fault !!!!!!!!!!
} // I cannot figure why ...
template<class T>
T List<T>::pop()
{
return extract(length-1);
}
int main(int argc, char **argv)
{
List<int> l;
l.resize(3);
for(int i=0;i<3;i++)
cin>>l[i];
l.resize(2);
cout<<l<<endl;
return 0;
}
I hope it's not a too kilometric doce, thanks in advance for who will read and try to help me.

Answer 1

In resize, the for loops change i and compare it with this->length, but both push and extract change this->length, so you're comparing two changing variables against each other.
This may be better a better approach:
while(this->length < length)
push(0);