::::::::::::::
array.cpp
::::::::::::::

/* 
  array.cpp
  class Myarray defines array with 
  - 1-indexing
  - unbounded dimension
*/

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

class Myarray {
  private:
    int dimension; 
    int* data; 
  public:
    Myarray(int dim); 
    Myarray(const Myarray& array);
    ~Myarray();
    int& element(int index); 
    void print(void);
}; 

Myarray::Myarray(int dim) {
  dimension = dim; 
  data = new int[dim]; 
}

Myarray::Myarray(const Myarray& array) {
  dimension = array.dimension; 
  data = new int[dimension]; 
  for (int i = 0; i < dimension; i++) 
    data[i] = array.data[i]; 
}

Myarray::~Myarray() {
  delete data; 
}

int& Myarray::element(int index) {
  if (index > dimension) {
    int* temp = new int[index*2]; 
    if (temp == NULL) {
      cout << "Myarray::element: run out of memory" << endl; 
      exit(EXIT_FAILURE); 
    }
    for (int i = 0; i < dimension; i++)
      temp[i] = data[i]; 
    for (int i = dimension; i < index*2; i++)
      temp[i] = 0; 
    dimension = index*2;
    delete data; 
    data = temp; 
  }
return(data[index-1]); 
}

void Myarray::print(void) {
  cout << "\nMyarray\n-------" 
       << "\ndimension: " << dimension 
       << "\ndata:\n";
  for (int i = 0; i < dimension; i++) 
    cout << i+1 << "\t:\t" << data[i] << "\n"; 
  cout << "-------\n" << endl; 
  return; 
}

int main() {

  Myarray a1(4); 
  for(int i = 1; i <= 4; i++) 
    a1.element(i) = i; 
  a1.print(); 

  Myarray a2(a1); 
  a2.print(); 

  a2.element(6) = 6;
  a2.element(7) = 7;
  a2.print(); 

  return(0);
}

::::::::::::::
array.out
::::::::::::::

Myarray
-------
dimension: 4
data:
1	:	1
2	:	2
3	:	3
4	:	4
-------


Myarray
-------
dimension: 4
data:
1	:	1
2	:	2
3	:	3
4	:	4
-------


Myarray
-------
dimension: 12
data:
1	:	1
2	:	2
3	:	3
4	:	4
5	:	0
6	:	6
7	:	7
8	:	0
9	:	0
10	:	0
11	:	0
12	:	0
-------


::::::::::::::
ascensore.cpp
::::::::::::::

/*
  ascensore.cpp
  tema del 25 gennaio 2000

  gestione ascensore
*/

#include <iostream.h>

class Ascensore {
private:
  short piano;  // locazione attuale
  short max_p;  // ultimo piano
  short utenti; // utenti nell'ascensore
  short max_u;  // capienza massima
  short fermate[4];         // lista fermate prenotate
  short fermate_prenotate;  // prenotazioni in fermate[]
public:
  Ascensore(short ultimo_piano, short massima_capienza);
  short locazione(void);  // indica la locazione attuale
  short persone(void);    // indica il numero di utenti nell'ascensore
  void display(void);	  // stampa le fermate in fermate[]
  void muovi(void);	  // esegue la prossima prenotazione in fermate
  void uscita(short persone); 	// uscita persone
  void entrata(short persone, short fermata);  
       // entrata nuove persone con una nuova prenotazione
};

Ascensore::Ascensore(short ultimo_piano, short massima_capienza) {
  // warning: nessun controllo sui dati
  piano = 0;
  max_p = ultimo_piano;
  utenti = 0;
  max_u = massima_capienza;
  fermate[0] = 0; fermate[1] = 0;
  fermate[2] = 0; fermate[3] = 0;
  fermate_prenotate = 0;
}

inline short Ascensore::locazione(void) {
  return (piano);
}

inline short Ascensore::persone(void) {
  return(utenti); 
}

void Ascensore::display(void) {
  if(fermate_prenotate == 0) 
    cout << "Nessuna fermata prenotata\n";
  else {
    cout <<"Fermate prenotate:\n";
    for(int i = 0; i < fermate_prenotate; ++i) 
      cout << i+1 <<"-a fermata al piano " << fermate[i] << "\n"; 
    cout << endl; 
  } // end else
  return; 
}

void Ascensore::muovi(void) {
  if(fermate_prenotate > 0) {
    fermate_prenotate--;
    piano = fermate[0];
    for (int i = 0; i < fermate_prenotate; ++i) 
      fermate[i] = fermate[i+1];
  }
  return; 
}

inline void Ascensore::uscita(short persone) {
  if (utenti >= persone) 
    utenti -= persone; 
}

void Ascensore::entrata(short persone, short fermata) {
  if ((utenti + persone <= max_u) 
      && (fermate_prenotate < 4)
      && (fermata <= max_p)) {
    utenti += persone; 
    fermate[fermate_prenotate] = fermata;
    fermate_prenotate++;
  } //end if
  return;
}

int main() {
  // test per la classe Ascensore

  Ascensore a1(37, 18); 

  a1.entrata(12, 17); 
  a1.entrata(3, 21); 
  cout << "locazione: " << a1.locazione() << "\n"; 
  cout << "persone: " << a1.persone() << "\n"; 
  a1.display(); 

  a1.muovi(); 
  a1.uscita(10); 
  a1.entrata(4, 7); 
  cout << "locazione: " << a1.locazione() << "\n"; 
  cout << "persone: " << a1.persone() << "\n"; 
  a1.display(); 

  a1.muovi(); 
  a1.entrata(2, 0); 
  cout << "locazione: " << a1.locazione() << "\n"; 
  cout << "persone: " << a1.persone() << "\n"; 
  a1.display(); 

  return(0); 
}


::::::::::::::
ascensore.out
::::::::::::::

locazione: 0
persone: 15
Fermate prenotate:
1-a fermata al piano 17
2-a fermata al piano 21

locazione: 17
persone: 9
Fermate prenotate:
1-a fermata al piano 21
2-a fermata al piano 7

locazione: 21
persone: 11
Fermate prenotate:
1-a fermata al piano 7
2-a fermata al piano 0


::::::::::::::
insieme.cpp
::::::::::::::

/*
  insieme.cpp
  tema del 23 settembre 1999

  rappresentazione mediante la classe Set di 
  un insieme e di alcune operazioni insiemistiche
*/

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

class Set {
private:
  unsigned int size; // numero di elementi;
  unsigned int max_el; // capienza massima dell'insieme
  int* content; // contenuto dell'insieme 
public:
  Set(unsigned int n);	// insieme vuoto con la max capienza specificata
  Set(const Set&);	// costruttore di copia
  ~Set();		// distruttore
  void add(int el);     // aggiungi el se non presente
  void del(int el);     // cancella el se presente
  void interval(int inf, int sup);  // cancella elementi < inf e > sup
  void split(int pivot, Set &a, Set &b); 
  // assegna ad a gli elementi < pivot ed a b gli elementi > pivot
  void print(); // stampa stato dell'oggetto
};

Set::Set(unsigned int n) {
  size = 0;
  max_el = n;
  content = new int[n];
}

Set::Set(const Set &h) {
  size = h.size;
  max_el = h.max_el;
  content = new int[max_el];
  for (int i = 0; i < size; ++i) {
    content[i] = h.content[i];
  }
}

Set::~Set() {
  delete content; 
}

void Set::add(int el) {
  // aggiungi el senza creare duplicazioni
  if (size < max_el) {
    int i = 0; 
    short trovato = 0; 
    while (i < size && !trovato) {
      if (content[i] == el)
	trovato = 1; 
      i++; 
    } // end while
    if (!trovato)
      content[size++] = el; 
  } // end if(size)
  return;
}

void Set::del(int el) {
  // assumo el sia presente al piu` una volta 
  for (int i = 0; i < size; i++) {
    if (content[i] == el) {
      for (int j = i; j < size-1; ++j)
	content[j] = content[j+1];
      size--;
      break; // esce dal for esterno
    } //end if
  } //end for
  return; 
}

void Set::interval(int inf, int sup) {
  int* temp = new int[max_el]; 
  int i_c = 0, i_t = 0; 

  while (i_c < size)
    if (content[i_c] >= inf && content[i_c] <= sup)
      temp[i_t++] = content[i_c++]; 
    else 
      i_c++; 
  // end while
  size = i_t; 
  delete content; 
  content = temp; 
  return; 
}

void Set::split(int pivot, Set &a, Set &b) {
  // cancella il contenuto degli oggetti a e b 
  a.size =0;
  b.size =0;
  for (int i = 0; i < size; ++i) 
    if (content[i] < pivot) 
      a.size++; 
    else if (content[i] > pivot)
      b.size++; 
  // end for
  a.content = new int[a.size]; 
  b.content = new int[b.size];
  int i_a = 0, i_b = 0;  
  for (int i = 0; i < size; ++i) 
    if (content[i] < pivot) 
      a.content[i_a++] = content[i]; 
    else if (content[i] > pivot)
      b.content[i_b++] = content[i]; 
  // end for
  return; 
}

void Set::print() {
  cout << "\nSet\n---"
       << "\nmax_el = " << max_el
       << "\nsize = " << size
       << "\nelementi:\n"; 
  for (int i = 0; i < size; i++) 
    cout << i+1 << " : " << content[i] << "\n";
  cout << "---" << endl; 
  return; 
}

int main() {
  // test per la classe Set

  Set s1(8); 
  s1.add(5); s1.add(7);
  s1.add(11); s1.add(13);
  s1.add(17); s1.add(19);
  s1.add(7); // test duplicati
  s1.print(); 

  Set s2(8); 
  s2.print(); 

  Set s3(s1); 
  s3.del(5); 
  s3.del(11);
  s3.del(19); 
  s3.print(); 

  Set s4 = s1; 
  s4.interval(9, 18); 
  s4.print(); 

  s1.split(11, s2, s4); 
  s2.print(); 
  s4.print(); 

  //  s1.print(); 
  //  s2.print();
  //  s3.print();
  //  s4.print(); 

  return(0); 
}
  

::::::::::::::
insieme.out
::::::::::::::

Set
---
max_el = 8
size = 6
elementi:
1 : 5
2 : 7
3 : 11
4 : 13
5 : 17
6 : 19
---

Set
---
max_el = 8
size = 0
elementi:
---

Set
---
max_el = 8
size = 3
elementi:
1 : 7
2 : 13
3 : 17
---

Set
---
max_el = 8
size = 3
elementi:
1 : 11
2 : 13
3 : 17
---

Set
---
max_el = 8
size = 2
elementi:
1 : 5
2 : 7
---

Set
---
max_el = 8
size = 3
elementi:
1 : 13
2 : 17
3 : 19
---



::::::::::::::
testo.cpp
::::::::::::::

/*
  testo.cpp
  tema del 24 giugno 1999

  testo di caratteri
*/

#include <iostream.h>

class Text {
private:
  long int size; // numero di caratteri ascii
  long int line_no; // numero di caratteri '\n'
  char* content; 
  // contenuto del testo: non occorre il terminatore 
  // '\0' poiche` il campo size contiene tale informazione
public:
  Text(char*); // inizializza ad una stringa assegnata
  Text(const Text&); // costruttore di copia
  ~Text();
  Text& cat(const Text&, const Text&);
    //concatenazione non distruttiva di due testi
  void print(void); // visualizza il testo
};

Text::Text(char* a) {
  size = 0;
  line_no = 0;
  int i = 0;
  while (a[i] != '\0') {
    size++;
    if (a[i] == '\n') line_no++;
    i++;
  }
  content = new char[size];
  for (i = 0; i < size; i++) 
    content[i] = a[i]; 
}

Text::Text(const Text& t) {
  size = t.size;
  line_no = t.line_no;
  content = new char[size];
  for(int i = 0; i < size; i++)
    content[i] = t.content[i];
}

Text::~Text() {
  delete content;
}

Text& Text::cat(const Text& a, const Text& b) {
  size = a.size + b.size;
  line_no = a.line_no + b.line_no; 
  content = new char[a.size+b.size];
  for (int i = 0; i < a.size; i++) {
    content[i] = a.content[i];
  }
  for (int i = 0; i < b.size; i++) {
    content[a.size+i] = b.content[i];
  }
  return (*this);
}

void Text::print(void) {
  // visualizza testo
  cout << "\nText\n========\n"
       << "size: " << size << "\n"
       << "line_no: " << line_no 
       << "\n----\ncontent:\n"
       << content; 
  cout << "\n========" << endl; 
  return; 
}

int main () {
  // test sulla classe Text
  Text t1("This may enable\nthe parser to prune search\n");
  Text t2(t1); 
  Text t3(""); 

  t1.print(); 
  t2.print();
  t3.print();

  t3.cat(t1, t2); 
  t3.print();

  return(0);
}


::::::::::::::
testo.out
::::::::::::::

Text
========
size: 43
line_no: 2
----
content:
This may enable
the parser to prune search

========

Text
========
size: 43
line_no: 2
----
content:
This may enable
the parser to prune search

========

Text
========
size: 0
line_no: 0
----
content:

========

Text
========
size: 86
line_no: 4
----
content:
This may enable
the parser to prune search
This may enable
the parser to prune search

========



::::::::::::::
incubatrice.cpp
::::::::::::::

/* 
  incubatrice.cpp

  gestione incubatrice per campioni biologici
*/

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

struct Campione {
  char* id; 
  int giorno; // [1..12]
  int mese; // [1..30]
};

class Incub {
private:
  int giorno; // giorno corrente
  int mese; // mese corrente
  int num_campioni; // campioni contenuti
  int max_campioni; // capienza massima
  Campione* contenuto; 
public:
  Incub(int gg, int mm, int max); 
  ~Incub ();
  short deposita(char* id_campione, int gg, int mm); 
  void aggiorna(); 
  void stampa();
};

Incub::Incub(int gg, int mm, int max) {
  // nessun controllo dati 
  giorno = gg; 
  mese = mm; 
  num_campioni = 0; 
  max_campioni = max; 
  contenuto = new(Campione[max_campioni]); 
}

Incub::~Incub() {
  for (int i = 0; i < num_campioni; i++)
    delete contenuto[i].id; 
  delete contenuto; 
}

short Incub::deposita(char* id_campione, int gg, int mm) {
  short result; 
  if (num_campioni < max_campioni) { 
    result = 1; 

    // queue
    contenuto[num_campioni].giorno = gg; 
    contenuto[num_campioni].mese = mm; 

    // copio identificatore
    int i = 0; 
    while (id_campione[i] != '\0') 
      i++; 
    contenuto[num_campioni].id = new(char[i+1]); 
    for (int j = 0; j < i+1; j++)
      (contenuto[num_campioni].id)[j] = id_campione[j]; 
    // ho copiato anche il terminatore
    num_campioni++;
  }
  else 
    result = 0; 
  // end if 

  return(result); 
}

void Incub::aggiorna() {
  // aggiorna data
  if (giorno < 30) 
    giorno++; 
  else {
    giorno = 1; 
    if (mese < 12) 
      mese++; 
    else 
      mese = 1; 
  } // end if

  // rimuovi campioni (ripeti delete)
  short fine = 0; 
  short trovato; 
  while (!fine) {

    // rimuovi singolo campione
    trovato = 0; 
    int i = 0; 
    while (i < num_campioni && !trovato) { 
      if (contenuto[i].giorno == giorno &&
	  contenuto[i].mese == mese) {
	trovato = 1; 
	delete (contenuto[i].id); 
	for (int j = i+1; j < num_campioni; j++) {
	  contenuto[j-1].id = contenuto[j].id; 
	  contenuto[j-1].giorno = contenuto[j].giorno; 
	  contenuto[j-1].mese = contenuto[j].mese; 
	} // end for(j)
	num_campioni--; 
      }  // end if
      i++; 
    } //  end while(i)
    if (!trovato)
      fine = 1;  // non vi sono piu` campioni scaduti
  }  // end while(!fine)
}

void Incub::stampa() {
  cout << "\nIncubatrice\n===========\n"
       << "giorno:\t" << giorno
       << "\nmese: \t" << mese 
       << "\ncampioni:\n";
  for (int i = 0; i < num_campioni; i++) 
    cout << "  " << i + 1 
         << "\n  gg: " << contenuto[i].giorno
	 << "\n  mm: " << contenuto[i].mese
	 << "\n  id: " << contenuto[i].id << "\n";
  // end for(i)
  cout << "===========\n" << endl; 
  return; 
}

int main() {
  // test classe Incub

  short result = 0; 
  Incub test(29, 4, 6); 
  result = test.deposita("b1", 2, 5);
  result = test.deposita("b2", 4, 5);
  result = test.deposita("a7", 2, 5);
  test.stampa(); 

  test.aggiorna(); 
  test.stampa(); 
  test.aggiorna(); 
  test.stampa(); 

  test.aggiorna(); 
  test.stampa(); 
  test.aggiorna(); 
  test.stampa(); 

  return(0); 
}

::::::::::::::
incubatrice.out
::::::::::::::

Incubatrice
===========
giorno:	29
mese: 	4
campioni:
  1
  gg: 2
  mm: 5
  id: b1
  2
  gg: 4
  mm: 5
  id: b2
  3
  gg: 2
  mm: 5
  id: a7
===========


Incubatrice
===========
giorno:	30
mese: 	4
campioni:
  1
  gg: 2
  mm: 5
  id: b1
  2
  gg: 4
  mm: 5
  id: b2
  3
  gg: 2
  mm: 5
  id: a7
===========


Incubatrice
===========
giorno:	1
mese: 	5
campioni:
  1
  gg: 2
  mm: 5
  id: b1
  2
  gg: 4
  mm: 5
  id: b2
  3
  gg: 2
  mm: 5
  id: a7
===========


Incubatrice
===========
giorno:	2
mese: 	5
campioni:
  1
  gg: 4
  mm: 5
  id: b2
===========


Incubatrice
===========
giorno:	3
mese: 	5
campioni:
  1
  gg: 4
  mm: 5
  id: b2
===========