Programma C++ - Ereditarietà, polimorfismo e strutture varie.

Classe String

#include <iostream.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

class String

{ char *itsString;

unsigned short itsLen;

String (unsigned short); //costruttore privato

public:

//Costruttori

String();

String(const char *const);

String(const String &);

~String();

//Operatori overloaded

char & operator[](unsigned short offset);

char operator[](unsigned short offset)const;

String operator+(const String &);

void operator+=(const String &);

String & operator=(const String &);

friend int operator==(const String &, const String &);

friend ostream & operator<<(ostream &, const String &);

friend istream & operator>>(istream &, String &);

//Metodi di accesso generali

unsigned short GetLen() const {return itsLen;}

const char* GetString() const {return itsString;}

};

//Costruttore di default crea una String con 0 byte

String::String()

{ itsString=new char[1];

itsString[0]='\0';

itsLen=0;

}

//Costruttore privato, usato solo dai metodi della classe per
creare una nuova String della dimensione richiesta
inizializzata dal carattere null.

String::String(unsigned short len)

{ itsString=new char[len+1];

for(unsigned short i=0; i<=len; i++)

itsString[i]='\0';

itsLen=len;

}

//Costruttore che converte a String un array di caratteri,
//il parametro un puntatore costante ad oggetto costante

String::String(const char *const cString)

{ itsLen=strlen(cString);

itsString=new char[itsLen+1];

for(unsigned short i=0; i<=itsLen; i++)

itsString[i]=cString[i];

itsString[itsLen]='\0';

}

//Costruttore di copia

String::String(const String &rhs)

{ itsLen=rhs.GetLen();

itsString=new char[itsLen+1];

for(unsigned short i=0; i<=itsLen; i++)

itsString[i]=rhs[i];

itsString[itsLen]='\0';

}

//Distruttore

String::~String()

{ delete [] itsString;

itsLen=0;

}

//Operatore = libera la memoria esistente e poi
//copia la String e le dimensioni

String & String::operator=(const String &rhs)

{ if (this==&rhs)

return *this;

delete [] itsString;

itsLen=rhs.GetLen();

itsString=new char[itsLen+1];

for(unsigned short i=0; i<=itsLen; i++)

itsString[i]=rhs[i];

itsString[itsLen]='\0';

return *this;

}

//Operatore [] non costante, restituisce un reference
//al carattere indicizzato per poterlo cambiare,
//usato come target di una assegnazione

char & String::operator[](unsigned short offset)

{ if(offset>itsLen)

//Se si esce dalle dimensioni si restituisce l'ultimo char

return itsString[itsLen-1];

else //Si restituisce l'elemento di indice offset

return itsString[offset];

}

//Operatore [] costante, da usare con oggetti costanti
//per es. col costruttore copia o nelle espressioni
//dove l'operatore può restituire un non reference o un reference const.

char String::operator[](unsigned short offset) const

{ if(offset>itsLen)

//Se si esce dalle dimensioni si restituisce l'ultimo char

return itsString[itsLen-1];

else //Si restituisce l'elemento di indice offset

return itsString[offset];

}

//Crea una nuova String concatenando alla
//String corrente la String rhs.

String String::operator+(const String &rhs)

{ unsigned short totLen=itsLen+rhs.GetLen();

String temp(totLen); //si chiama il costruttore privato

for (unsigned short i=0; i<itsLen; i++)

temp[i]=itsString[i];

for (unsigned short j=0; j<rhs.GetLen(); j++, i++)

temp[i]=rhs[j];

temp[totLen]='\0';

return temp;

}

//Cambia la String corrente, non restituisce nulla,
//concatenando alla String corrente rhs in coda.

void String::operator+=(const String &rhs)

{ unsigned short rhsLen=rhs.GetLen();

unsigned short totLen=itsLen+rhs.GetLen();

String temp(totLen);

for (unsigned short i=0; i<itsLen;i++)

temp[i]=itsString[i];

for (unsigned short j=0; j<rhsLen; j++,i++)

temp[i]=rhs[i-itsLen]; //Si copia rhs

temp[totLen]='\0';

*this=temp;

}

int operator==(const String &s1, const String &s2)

{ return strcmp(s1.GetString(), s2.GetString())==0;

}

ostream & operator<<(ostream &os, const String &s)

{ return os << s.GetString();

}

istream & operator>>(istream &is, String &s)

{ char buf[256];

is >> buf;

s = buf;

return is;

}

Classe iteratore

template <class T>

class Iterator

{ protected:

// Indica se è finita la lista
// deve essere aggiornata dalla classe derivata

int iterationComplete;

public:

// costruttore

Iterator();

// Metodi richiesti per l'iteratore

virtual void Next() = 0;

virtual void Reset() = 0;

// Metodo per recupero e modifica del dato

virtual T& Data() = 0;

// test fine lista

virtual int EndOfList() const;

};

// Pone iterationComplete a 0 (False)

template <class T>

Iterator<T>::Iterator(): iterationComplete(0)

{}

// restituisce il valore iterationComplete.

template <class T>

int Iterator<T>::EndOfList() const

{ return iterationComplete;

}

Classe List

template <class T>

class List

{ protected:

// Numero di elementi della lista aggiornato dalle classi derivate

int size;

public:

// costruttore

List();

// distruttore virtuale necessario per classi derivate
// che usano allocazione di memoria dinamica

virtual ~List();

// metodi di accesso alla lista

virtual int ListSize() const;

virtual int ListEmpty() const;

virtual int Find (T& item) = 0;

// Metodi di modifica della lista: funzioni virtuali pure

virtual void Insert(const T& item) = 0;

virtual void Delete(const T& item) = 0;

virtual void ClearList() = 0;

};

// costruttore pone size a 0

template <class T>

List<T>::List(): size(0)

{}

//distruttore virtuale

template <class T>

List<T>::~List()

{}

// restituisce size

template <class T>

int List<T>::ListSize() const

{ return size;

}

// test per una lista vuota

template <class T>

int List<T>::ListEmpty() const

{ return size == 0;

}

Classe Node

template <class T>

class Node

{ Node<T> *next; //next l'indirizzo del nodo successivo

public:

T data; //il dato pubblico

//Costruttore

Node (const T& item, Node<T>* ptrnext =NULL);

//Metodi per modificare la lista

void InsertAfter (Node<T> *p);

Node<T> *DeleteAfter ();

//Metodo per avere l'indirizzo del nodo successivo

Node<T> *NextNode () const;

};

//Implementazione della classe Node

template <class T>

Node<T>::Node (const T& item, Node<T>* ptrnext) :

data(item), next(ptrnext)

{}

template <class T>

void Node<T>::InsertAfter (Node<T> *p)

{ //p punta al successore del nodo corrente
//e il nodo corrente punta a p

p->next =next;

next =p;

}

template <class T>

Node<T> *Node<T>::DeleteAfter ()

{ //Salvare l'indirizzo del nodo da cancellare

Node<T> *tempPtr =next;

//Se non c'è un successore restituisce NULL

if (next == NULL)

return NULL;

//Il nodo corrente punta al successore di tempPtr

next = tempPtr->next;

//Restituisce il puntatore al nodo sconnesso

return tempPtr;

}

template <class T>

Node<T> *Node<T>::NextNode () const

{ return next;

}

Classe lista linkata

template <class T>

class LinkedList

{ //Puntatori per accedere alla testa e alla coda della lista

Node<T> *front, *rear;

//Puntatori per le operaz. di Insert e Delete

Node<T> *prevPtr, *currPtr;

//Numero di item nella lista

int size;

//Posizione nella lista, usata da Reset

int position;

//Metodi privati per allocare e deallocare nodi

Node<T> *GetNode (const T& item, Node<T>* ptrNext=NULL);

void FreeNode (Node<T> *p);

//Copia lista L nella lista corrente

void CopyList (const LinkedList<T>& L);

public:

//Costruttori

LinkedList ();

LinkedList (const LinkedList<T>& L);

//Distruttore

~ LinkedList ();

//Operatore di assegnazione