Ho scritto una classe List (per distinguerla da list) che per ora ha solo le operazioni di pop e di push (proprio come se fosse una pila):
codice:
#include <iostream>
#include <cassert>

using namespace std;

template<class T>
class List
{
    public:
    List<T>();
    ~List<T>();
    protected:
    List<T> (T info);
    public:
    void push(T info);
    void pop();
    friend ostream& operator<< (ostream& out, List<T> &l)
    {
        List<T>* ptr=l.next;
        while(ptr!=&l)
        {
            out << *(ptr->info) << "\t";
            ptr=ptr->next;
        }
        return out;
    }
    friend List<T>& operator+= (List<T>& l1, List<T>& l2)
    {
        List<T>* temp=new List<T> ();
        List<T>* ptr;
        ptr=l1.next;
        while(ptr!=&l1)
        {
            temp->push(*(ptr->info));
            ptr=ptr->next;
        }
        ptr=l2.next;
        while(ptr!=&l2)
        {
            temp->push(*(ptr->info));
            ptr=ptr->next;
        }
        return *temp;
    }
    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>
void List<T>::push(T info)
{
    List<T>* ptr,*temp;
    temp=this->prev;
    ptr=new List<T>(info);
    temp->next=ptr;
    ptr->prev=temp;
    this->prev=ptr;
    ptr->next=this;
    length++;
}


template<class T>
void List<T>::pop()
{
    List<T>* ptr=this->prev->prev;
    assert(length>0);
    delete this->prev;
    ptr->next=this;
    this->prev=ptr;
    length--;
}

int main(int argc, char **argv)
{
    List<int> *l=new List<int>();
    List<int> *l2=new List<int>();
    for(int i=0;i<10;i++)
        l->push(i);
    for(int i=10;i<20;i++)
        l2->push(i);
    *l+=*l2;
    cout<<*l<<endl;
    delete l;
    delete l2;
    return 0;
}
Length contiene la lunghezza della lista, non ho avuto problema con l' overloading dell' operatore <<.
Un problema che ho riscontrato è che sul libro che ho (il Deitel) mi fa l' esempio dell' overloading dell' operatore += passando come argomento solo un parametro, ma se provo a dargli un parametro mi dice che deve per forza avere 2 parametri.
Ma vengo al sodo: il problema è proprio nel main, quando provo a concatenare due liste (anche s enon mi da nessun errore ne warning):
codice:
int main(int argc, char **argv)
{
    List<int> *l=new List<int>();
    List<int> *l2=new List<int>();
    for(int i=0;i<10;i++)
        l->push(i);
    for(int i=10;i<20;i++)
        l2->push(i);
    *l+=*l2;
    cout<<*l<<endl;
    delete l;
    delete l2;
    return 0;
}
Se provo a stampare l mi stampa solo i primi numeri da 0 a 9 anzichè da 0 a 19, in pratica non ha concatenato niente, l' operazione è "sterile".
Penso che il problema sia provo quando faccio l' overloading:
codice:
friend List<T>& operator+= (List<T>& l1, List<T>& l2)
    {
        List<T>* temp=new List<T> ();
        List<T>* ptr;
        ptr=l1.next;
        while(ptr!=&l1)
        {
            temp->push(*(ptr->info));
            ptr=ptr->next;
        }
        ptr=l2.next;
        while(ptr!=&l2)
        {
            temp->push(*(ptr->info));
            ptr=ptr->next;
        }
        return *temp;
    }
Ma non riesco a capire cosa sbaglio