Sa implementeze o clasa template ce implemeteaza notiunea de Lista.

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <iostream>


using namespace std;

/* Declararea tipului abstract Lista */

template <class TipI>
class Lista;


/** Clasa Nod al unei liste*/
template <class TipI>
class Nod {
      TipI info; //informatia
      Nod<TipI> *next;//legatura catre urmatorul nod din lista
   public:
      Nod();//Constructor Implicit
      Nod(TipI info,Nod<TipI>* next=0);//Constructor de initializare
      TipI getInfo();//
      void setInfo(TipI info);
      Nod<TipI> *getNext();
      void setNext(Nod<TipI>* next);
      int operator == (Nod<TipI>&);
      friend class Lista<TipI>;

};

/*Constructor implicit*/
template <class TipI>
Nod<TipI>::Nod(){
 next=0;
}

/*Constructor de initializare*/
template <class TipI>
Nod<TipI>::Nod(TipI info, Nod<TipI>* next){
 this->info=info;
 this->next=next;
}
/* Intoarce informatia stocata in nod*/
template <class TipI>
TipI Nod<TipI>::getInfo(){
 return info;
}
/* Seteaza informatia stocata in nod */
template <class TipI>
void Nod<TipI>::setInfo(TipI info){
     this->info=info;
}
/* Intoarce adresa elementului urmator*/
template <class TipI>
Nod<TipI> *Nod<TipI>::getNext(){
 return next;
}
/* Seteaza adresa elementului urmator*/
template <class TipI>
void Nod<TipI>::setNext(Nod<TipI>* next){
     this->next=next;
}
/* Supraincarcarea operatorului == */
template <class TipI>
int Nod<TipI>::operator == (Nod<TipI> &n){
   return this->info==n.info;
}


/** Clasa Lista simplu inlatuita*/

template <class TipI>
class Lista {
  protected:
   Nod<TipI> *prim;
   Nod<TipI> *ultim;

  public:
   Lista(); //constructor implicit
   Lista(const Lista<TipI>& L); //constructor de copiere
   ~Lista(); //destructor

   int isEmpty();
   void clear();
   void addElement(TipI info);
   Nod<TipI>* getFirst();//intoarce primul elemnt din lista
   Nod<TipI>* getLast(); //intoarce ultimul element din lista
   Nod<TipI>* getElementAt( int index);
   int getNrElemente();
   void print();
   TipI& operator[] (int index);
   Lista<TipI>& operator=(Lista<TipI> &);
};

/** Implementarea clasei Lista*/
template <class TipI>
Lista<TipI>::Lista(){
   prim=ultim=0;
}

template <class TipI>
Lista<TipI>::Lista(const Lista<TipI>& L){
  Nod<TipI> *p;          
  prim=ultim=0;
  p=L.prim;
  while (p){
     addElement(p->info);
     p = p->next;   
  }          
}

template <class TipI>
Lista<TipI>::~Lista(){
   clear();                   
}                      
                     
template <class TipI>
int Lista<TipI>::isEmpty(){
 return prim==0;
}
template <class TipI>
void Lista<TipI>::clear(){
  Nod<TipI> *p, *q;     
  p = prim;
  while (p){
     q=p;
     p=p->next;
     delete q;   
  }
  prim = ultim = 0;  
}

template <class TipI>
Lista<TipI>& Lista<TipI>:: operator=(Lista<TipI> &L){
  clear();
  Nod<TipI> *p =L.prim;
  while(p){
   addElement(p->info);
   p=p->next;
  }

  return *this;
}

template <class TipI>
TipI& Lista<TipI>::operator[] (int index){
    return getElementAt(index)->info;
}

/** Adauga un nod la sfarsitul listei*/
template <class TipI>
void Lista<TipI>::addElement(TipI inf){
 Nod<TipI> *p;
 p=new Nod<TipI>(inf,0);
 if(isEmpty()){
  prim=ultim=p;
 } else {
  ultim->next=p;
  ultim = p;
 }
}
template <class TipI>
Nod<TipI>* Lista<TipI>::getFirst(){
 return prim;
}

template <class TipI>
Nod<TipI>* Lista<TipI>::getLast(){
 return ultim;
}

template <class TipI>
Nod<TipI>* Lista<TipI>::getElementAt( int index){
 int i;          
 Nod<TipI>* p;
 for(i=0,p=prim;i<index&&p!=0;i++,p=p->next);

 return p;

}


template <class TipI>
int Lista<TipI>::getNrElemente(){
 int n=0;
 Nod<TipI>* p=prim;
 while(p){
  n++;
  p=p->next;
 }
 return n;
}

template <class TipI>
void Lista<TipI>::print(){
 Nod<TipI>* p= getFirst();
 while(p){
  cout<<p->getInfo()<<",";
  p=p->getNext();
 }
 cout<<"\b ";

}

int main(){
Lista<int> li; //lista ce contine elemente numere intregi
li.addElement(1);
li.addElement(2);
li.addElement(4);
li.print();
Lista<int> l2 = li;
cout<<endl<<"================================="<<endl;
l2[1]=12;
l2.print();
cout<<endl<<"================================="<<endl;
li.print();
cout<<endl<<"================================="<<endl;
Lista<float> lf; //lista ce contine elemente numere reale
lf.addElement(1.2);
lf.addElement(7.3);
lf.print();
getch();
}