[Corsopoc] (no subject)

Emanuele Di Saverio hazam@tiscalinet.it
Tue, 18 Feb 2003 19:12:09 +0100


This is a multi-part message in MIME format.

------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: text/plain;
	charset="iso-8859-1"
Content-Transfer-Encoding: 8bit

Raga se vi puņ essere d'aiuto ecco alcuni esercizi che avevo svolto per
l'orale ma che sono risultati inutili; speriamo che almeno servano a
qualcuno di voi.


Emanuele Di Saverio
---------------------------------------------
Remove NOSPAM manually for reply
Scusate le vaccate se  ne dico!

------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="CinqueFilosofi.java"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
	filename="CinqueFilosofi.java"

import java.awt.*;
import java.awt.event.*;

class Filosofo extends Thread {=20
    final int mangiando=3D2;
    final int pensando=3D0;
    final int volendomangiare=3D1;
    protected String nome;=20
    protected MonitorBastoncini monitor;=20
    protected int   ID;=20
	private int stato;
	public String getNome() { return nome; }
	public int getStato() {return stato;}

    public Filosofo(int ID,MonitorBastoncini monitor)=20
    {=20
		switch (ID)
		{
			case 0: this.nome=3D "Aristotele"; break;
        	case 1: this.nome=3D "Gorgia"; break;
        	case 2: this.nome=3D "Parmenide"; break;
        	case 3: this.nome=3D "Platone"; break;
        	case 4: this.nome=3D "Socrate"; break;
        	default: this.nome=3D"ERRORE";
        }
        this.monitor=3Dmonitor;=20
        this.ID=3DID;=20
    }  =20
    =20

    public void run()=20
    {=20
       while (true)=20
        {=20
       		stato=3Dpensando;
			try=20
				{=20
					sleep(((long)Math.random()*10000+1000));=20
				} catch( InterruptedException ie ) {}=20
        	stato=3Dvolendomangiare;
        	monitor.prendi(ID);=20
	    	stato=3Dmangiando;
        	try
        		{=20
        			sleep((long)(Math.random()*10000+1000));
        		} catch( InterruptedException ie ){}=20
        	monitor.posa(ID);=20
        }=20

    }=20
   =20
   =20
   =20
     }

//MONITOR
 class MonitorBastoncini {=20
    private int bastoni[]=3D{2,2,2,2,2};=20
    public synchronized void prendi( int ID )
    {=20
        while( bastoni[ID] <2 ){=20
            try { wait(); } catch(InterruptedException ie) {}=20
        }=20

		bastoni[(ID)]-=3D2;		 //	per chiarezza
        bastoni[(ID+1)%5]--;   // bastoncino a destra=20
		bastoni[(ID+4)%5]--;   // bastoncino a sinistra=20

    }=20

    public synchronized void posa( int ID )
    {=20
        bastoni[(ID)]+=3D2;		 //	per chiarezza
        bastoni[(ID+1)%5]++;   // bastoncino a destra=20
        bastoni[(ID+4)%5]++;   // bastoncino a sinistra=20
        notifyAll();=20
    }=20

}

public class CinqueFilosofi extends Frame
{
MonitorBastoncini monitor;=09
Filosofo filosofi[]=3Dnew Filosofo[5];=09
Color colori[]=3Dnew Color[3];

public CinqueFilosofi()
	{
		monitor=3D new MonitorBastoncini();
		for (int i=3D0; i<5;i++)
			filosofi[i]=3D new Filosofo(i,monitor);
		setLayout(null);
		setTitle("5 Filosofi");
		setBounds(30,30,530,530);
		addWindowListener(new Chiudimela());
		Button b=3D new Button("INIZIA");
		b.setBounds(420,420,80,40);
		b.addActionListener(new LanciaListener());
		add(b);
		colori[0]=3DColor.black;
		colori[1]=3DColor.blue;
		colori[2]=3DColor.orange;
		setVisible(true);
}

public void paint(Graphics g)
{
//DISEGNO LEGENDA
g.setColor(colori[0]);
g.drawString("Legenda", 10,40);
g.drawString("Pensare", 40,60);
g.drawString("Pensare di Mangiare", 40,80);
g.drawString("Mangiare", 40,100);
g.fillRect(20,50,20,20);
g.setColor(colori[1]);
g.fillRect(20,70,20,20);
g.setColor(colori[2]);
g.fillRect(20,90,20,20);
//DISEGNO TAVOLO
g.setColor(Color.red);
g.fillOval(150,150,200,200);=09
//DISEGNO FILOSOFI
g.setColor(Color.black);
g.drawOval(150,150,200,200);
g.drawOval(120,100,70,70);
g.drawString(filosofi[0].getNome(), 60,150);
g.drawOval(310,100,70,70);
g.drawString(filosofi[1].getNome(), 310,90);
g.drawOval(350,270,70,70);
g.drawString(filosofi[2].getNome(), 360,250);
g.drawOval(220,360,70,70);
g.drawString(filosofi[3].getNome(), 220,450);
g.drawOval(80,270,70,70);
g.drawString(filosofi[4].getNome(), 80,250);
//getStato() ritorna 0,1,2 che vanno a pescare i colori nell'array =
colori[3]
g.setColor(colori[filosofi[0].getStato()]);
g.fillOval(120,100,70,70);
g.setColor(colori[filosofi[1].getStato()]);
g.fillOval(310,100,70,70);
g.setColor(colori[filosofi[2].getStato()]);
g.fillOval(350,270,70,70);
g.setColor(colori[filosofi[3].getStato()]);
g.fillOval(220,360,70,70);
g.setColor(colori[filosofi[4].getStato()]);
g.fillOval(80,270,70,70);

}

private class Chiudimela extends WindowAdapter
	{
		public void windowClosing(WindowEvent e)
			{ System.exit(0);}
    }
  =20
 =20
public static void main(String str[])
    	{=20
        CinqueFilosofi uno=3D new CinqueFilosofi();=20
       	}  =20
=20
=09
=09
=09
	private class LanciaListener implements ActionListener=20
	{
		Thread thread;
		public void actionPerformed (ActionEvent e)=20
		{
				if (thread =3D=3D null)
				{=09
				thread=3D new Azzuffata(filosofi);
			    thread.start();
			    }
		}
	}

	private class Azzuffata extends Thread
	{
	Filosofo[] filosofi;
	public Azzuffata(Filosofo[] filosofi)
		{
		this.filosofi=3Dfilosofi;
		}
=09
	public void run()
	{
		repaint();
		for (int i=3D0; i<5; i++)
			filosofi[i].start();
		while (true)=20
		{
			repaint();
			try
			{
				sleep(50);
			} catch (InterruptedException e) {}
		}
    }
  }
}
------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="Mattone.java"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
	filename="Mattone.java"

import java.awt.*;

class Mattone
{
	private Color colore;
	private Rectangle locazione;
	public Mattone(int x, int y)
	{
		locazione= new Rectangle( x,y, 40,20);
		colore = new Color((float)Math.random(), 
							(float)Math.random(), 
							(float)Math.random() );
	}
	int y()
	{
		return locazione.y;
	}
	
	int x()
	{
		return locazione.x;
	}
	
	public void paint(Graphics g)
	{
		g.setColor(colore);
		g.fillRect(locazione.x, locazione.y, locazione.width, locazione.height);
		g.setColor(Color.black);
		g.drawRect(locazione.x, locazione.y, locazione.width, locazione.height);
	}
	
}
------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="Barra.java"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
	filename="Barra.java"

import java.awt.*;

class Barra
{
	private Rectangle locazione;
	private double velbarra;
	public Barra(int x)
	{
		locazione = new Rectangle(x -10, 380, 50,15);
	}
	int y()
	{
		return locazione.y;
	}
	int x()
	{
		return locazione.x;
	}
	
	void setVelBarra( double v)
	{
		velbarra=v/4;
	}
	
	double getVelBarra()
	{return velbarra;}
	
	public void move(int x)
	{
	locazione.translate(x-locazione.x, 0);
	}
	
	public void paint(Graphics g)
	{
	g.setColor(Color.yellow);
	g.fillRect(locazione.x, locazione.y, locazione.width, locazione.height);	
	g.setColor(Color.black);
	g.drawRect(locazione.x, locazione.y, locazione.width, locazione.height);
	}
}
------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="Biglia.java"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
	filename="Biglia.java"

import java.awt.*;

public class Biglia {
//Una biglia e' un Rectangle Java in movimento, con lati uguali =
(quadrato)=20
//Di un tale rettangolo viene colorato e visualizzato il solo ovale =
inscritto (cerchio).=20
//ATTRIBUTI
	protected Rectangle locazione; //location e' una variabile di tipo =
(puntatore a) Rettangolo
	protected double dx; // Proiezione orizzontale di spostamento unitario =
(PASSO.
	protected double dy; //Proiezione verticale di spostamento unitario.
	protected Color colore; //color e' una variabile di tipo (puntatore a) =
Color
	final static int maxVX=3D30;
	final static int maxVY=3D30;
	//COSTRUTTORI
	public Biglia (int x, int y, int r)
	{
		locazione =3D new Rectangle(x-r, y-r, 2*r, 2*r);
		//UN OGGETTO Rectangle E' DEFINITO TRAMITE LE COORDINATE DEL SUO =
VERTICE IN ALTO A SINISTRA, LA BASE E L'ALTEZZA.
		colore =3D Color.blue;
		dx =3D 0;
		dy =3D 0;
		//UNA BIGLIA NASCE BLU E FERMA
	}
=09
	//METODI
	//ASSEGNAZIONE DI VALORE AGLI ATTRIBUTI

	public void setColor (Color nuovoColore)
				{ colore =3D nuovoColore;	}

	public void setMotion (double ndx, double ndy)
				{ dx =3D ndx /4; dy =3D ndy/4;=20
					if (dx >30) dx=3DmaxVX;
					if (dy >30) dy=3DmaxVY;
				}
=09
	//ACCESSO AGLI ATTRIBUTI

	public int raggio ()
				{ return locazione.width / 2; }
=09
	public int x () //ASCISSA DEL CENTRO
				{ return locazione.x + raggio(); }
=09
	public int y () //ORDINATA DEL CENTRO
				{ return locazione.y + raggio(); }
=09
	public double xMotion ()
				{ return dx; }

	public double yMotion ()
				{ return dy; }

	public Rectangle region () { return locazione; }

	// MODIFICATORI DI ATTRIBUTI
	public void moveTo (int x, int y) //(RI)POSIZIONA LA BIGLIA
				{ locazione.setLocation(x, y); }

	public void move () //SPOSTA LA BIGLIA DI UN PASSO
				{ locazione.translate ((int) dx, (int) dy); }
=09
	public void paint (Graphics g)
	{
		g.setColor (colore);
		g.fillOval (locazione.x, locazione.y, locazione.width, =
locazione.height);
	}
}
------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="BigliaSpecializzata.java"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
	filename="BigliaSpecializzata.java"

import java.util.Vector;
import java.awt.*;


public class BigliaSpecializzata extends Biglia=20
{
=09
		private static final int deltaX =3D -10;=20
		private static final int deltaY =3D -25;=20
	public BigliaSpecializzata (int sx, int sy)=20
	{
		//LA BIGLIA SPECIALIZZATA NASCE CON RAGGIO 10 E IN MOTO VERSO L'ALTO =
CON PICCOLA INCLINAZIONE CASUALE=20
		super(sx, sy, 10); //CHIAMA COSTRUTTORE DELLA CLASSE MADRE
			super.setMotion (deltaX , deltaY);
	}

	public void move ()
	{
		super.move();
	}
=09
	private boolean urtocheck(Mattone matt)
	{
	if (y() < matt.y()+27 && y() > matt.y()-7)
		if (x() < matt.x()+47 && x() > matt.x()-7)
			{
				if ( y() < matt.y()+23) rimbalzaX();
				 else rimbalzaY(0);
						return true;
			}
	return false;
	}

	public void urto(Vector mattoni)
	{
	for (int i=3D0; i <mattoni.size(); i++)
			if (urtocheck( (Mattone)mattoni.elementAt(i) ))
					mattoni.remove(i);
	}
=09
	public void urtoBarra( Barra barra)
	{
		if (this.y() >=3D barra.y()-4 && this.y() <=3D barra.y())=20
					if( this.x() <=3D barra.x()+55 && this.x()>=3D barra.x()-5)=09
						((BigliaSpecializzata)this).rimbalzaY((int)barra.getVelBarra());
	}
	public void rimbalzaX()
		{
			dx=3D-dx;
		}

	public void rimbalzaY(int velbarraX)
		{
			dy=3D-dy;
			dx=3Ddx+velbarraX;
		}

}

------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="GiocoDiBiglie.java"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
	filename="GiocoDiBiglie.java"

//ADATTATO DA LIBRO DI TESTO
//VERSIONE DA TESTARE 2002.01.07
import java.awt.*; // PER Frame;
import java.awt.event.*; //GESTIONE EVENTI
import java.awt.Image.*;
import java.util.Vector; //ARRAY DINAMICO

public class GiocoDiBiglie extends Frame {
	//SI EREDITA DA Frame
	final int statoNiente=3D3;
	final int statoPerso=3D2;
	final int statoVinto=3D1;
	final int statoGiocando=3D0;
	public static final int LarghezzaCornice =3D 500; //COSTANTE LARGHEZZA =
CORNICE DI GIOCO
	public static final int AltezzaCornice =3D 500; //COSTANTE ALTEZZA =
CORNICE DI GIOCO
	public static final int TS =3D 15; //TEMPO (MINIMO) DI SONNO PER =
PROCESSO
	private Barra barra;
	private Biglia biglia;
	private int posbarra;
	private Vector mattoni;
	private int stato;	//COSTRUTTORE
	public GiocoDiBiglie() {
		setLayout(null);
		setTitle ("Gioco Di Biglie");
		setBounds(30,30, LarghezzaCornice+30, AltezzaCornice+30);
		barra=3D new Barra(200);
		Button b=3D new Button("LANCIA");
		mattoni=3D new Vector();
		for (int j=3D0; j<3;j++)
			for (int i=3D0; i<10; i++)
				mattoni.addElement( new Mattone(i*40,j*20+30));	=09
		b.setBounds(420,420,80,40);
		b.addActionListener(new LanciaListener());
		add(b);
		setVisible(true);
		addMouseMotionListener( new MuoviMouse());
		addWindowListener(new Chiudimela());
		stato=3DstatoNiente;
		}

	private class MuoviMouse implements MouseMotionListener
	{
	public void mouseDragged(MouseEvent e) {}
    public void mouseMoved(MouseEvent e) {
    	 try
    	 {
    	 int a=3De.getX();
    	 if(a < 350)=20
    	 		barra.move(a );
    	 				else barra.move(350);
		 barra.setVelBarra( (a-posbarra));
		 posbarra=3Da;	    =09
    	}catch (NullPointerException g) {}
    	 } =09
	}

	private class Chiudimela extends WindowAdapter
	{
		public void windowClosing(WindowEvent e)
			{ System.exit(0);}
    }

	private class LanciaListener implements ActionListener {
		public void actionPerformed (ActionEvent e) {
				if (stato!=3DstatoGiocando){
				biglia =3D new BigliaSpecializzata(350,350);=20
				Thread newThread =3D new ProcessoBiglia (biglia);=20
				newThread.start();}
		}
	}

	//CLASSE PROCESSO LEGGERO BIGLIA
	private class ProcessoBiglia extends Thread {
		private Biglia laBiglia;

		//COSTRUTTORE
		public ProcessoBiglia(Biglia unaBiglia) {
			laBiglia =3D unaBiglia;
		}

		//(RI)ATTIVAZIONE DELLA BIGLIA. NON CHIAMARE DIRETTAMENTE MA TRAMITE =
DISPATCHER
		public void run () {
			stato=3DstatoGiocando;
			while (stato =3D=3D0) {
				if (mattoni.size()=3D=3D0) stato =3DstatoVinto;
				if (laBiglia.y()>420) stato=3DstatoPerso;
				laBiglia.move ();
				repaint();
				((BigliaSpecializzata)laBiglia).urto(mattoni);
				((BigliaSpecializzata)laBiglia).urtoBarra(barra);
				//Collisioni con cornice trattate direttamente
				if ( laBiglia.y()<40)
					((BigliaSpecializzata)laBiglia).rimbalzaY(0);
				if (laBiglia.x() >385 || laBiglia.x()<8)=09
					((BigliaSpecializzata)laBiglia).rimbalzaX();
				try {
					sleep(TS);
				} catch (InterruptedException e) { System.exit(0); }
			}stato=3DstatoNiente;
		}
	}

	public void paint (Graphics g) {
		//DISEGNO DELLE CORNICI
		if (stato=3D=3DstatoPerso) g.drawString("HAI PERSO!",5,440);
		if (stato=3D=3DstatoVinto) g.drawString("HAI VINTO!",5,440);
		g.setColor(Color.black);
		g.drawRect(0,0,400,400);
		g.setColor (Color.white);
		g.fillRect(0,0,400,400);
		barra.paint(g);
		for (int i=3D0; i< mattoni.size(); i++)
			((Mattone)(mattoni.elementAt(i))).paint(g);
		try {	biglia.paint(g);}		//Se si omettesse il try catch si hanno degli =
strani=20
	catch (NullPointerException e) {}	//	warning per NullPointer a runtime, =
dato che biglia
		}								//potrebbe essere ancora null se non fosse stata creata in =
thread.run()

	public static void main (String [ ] args) {
		GiocoDiBiglie mondoGioco =3D new GiocoDiBiglie();
	}
}

------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="Menu.h"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
	filename="Menu.h"

#ifndef MENU_H
#define MENU_H
#include <stdlib.h>
#include <string>
// Classe astratta
class Opzione {
public:
//Costruttore
 Opzione() {};
 Opzione(const string &etichettaOpzione){
    etichetta=3D etichettaOpzione;}
 //Segue metodo virtuale puro
 virtual void attiva(void) =3D 0;

public:
  string etichetta;
};


class Menu:public Opzione {
public:
 Menu(const string &etichettaMenu,=20
      int MaxNumOpzioni);
 ~Menu();
 void defOpzione(Opzione *OpzPt);
 void attiva(void);
private:
  Opzione **listaOpzioni;
  int numOpzioni, MxNumOpz;
};


class Azione:public Opzione {
public:
 Azione(const string &etichettaAzione,=20
      void (*funzPt)(void),=20
      Opzione *opzPt=3DNULL);
 void attiva(void);
// Stampa schermata e attiva il Menu
private:
  Opzione *OPt;
  void (*FPt)();
};
#endif;

Menu::Menu(const string &etichettaMenu,=20
           int MaxNumOpzioni)
               =20
//Nota chiamate del costruttore di Opzione
{
 etichetta=3DetichettaMenu;
 MxNumOpz =3D MaxNumOpzioni;
=20
 if (MxNumOpz <=3D0) {
  cout << "Errore in Menu(): Max Num.opzioni <=3D 0\n";
  system("PAUSE");
  exit (EXIT_FAILURE);
 }
 else {listaOpzioni=3D new Opzione *[MxNumOpz];
    if (listaOpzioni =3D=3D NULL) {
       cout << "Menu(): Mem. Dinamica Insufficiente\n";
       exit (EXIT_FAILURE);
         }
    }
  numOpzioni =3D0;
}

Menu::~Menu() {
 for (int i=3D0; i<numOpzioni;i++)
    delete listaOpzioni[i];
    delete listaOpzioni;
    cout << "distruzione totale \n";
}
=20
=20
void Menu::defOpzione(Opzione * OpzPt){

  if (numOpzioni < MxNumOpz) {
   listaOpzioni[numOpzioni]=3D OpzPt;
   ++numOpzioni;
  }
  else {
   cout << "Menu.defOpzione: Fallimento/n";
   exit(EXIT_FAILURE);
  }
}

void Menu:: attiva(void){
// Stampa schermata e attiva Menu
 int scelta;
 do {
  // Stampa schermata
   cout<< "\n"<< etichetta << "\n";=20
   for (int i=3D0; i <numOpzioni; ++i) {
     cout << i << "\t";
     if (listaOpzioni[i] !=3D NULL ) cout << listaOpzioni[i]->etichetta;
          else cout << "NULL";
     cout << "\n";
   }
   cout << "Selezionare la opzione:    ";
  cin >> scelta;
 }
 while (scelta< 0 || scelta >=3D numOpzioni|| listaOpzioni[scelta] =
=3D=3D NULL);
     ( listaOpzioni [scelta] )-> attiva ();
}
=20
Azione:: Azione(
           const string &etichettaAzione,
           void (*funzPt)(void),=20
           Opzione *opzPt           )=20
{
 etichetta=3DetichettaAzione;
 FPt =3D funzPt;
 OPt =3D opzPt;
}

void Azione:: attiva(void) {
 if (FPt !=3D NULL)
 FPt();
 else {cerr << "ERR:puntatore a funzione in Azione::attiva NULL\n"; =
system("PAUSE"); exit(EXIT_FAILURE);}
 OPt -> attiva();
}






------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="calcolatriceOOP.dev"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
	filename="calcolatriceOOP.dev"

[Project]
FileName=calcolatriceOOP.dev
Name=Console App
UnitCount=2
Type=1
Ver=1
ObjFiles=
Includes=
Libs=
PrivateResource=
ResourceIncludes=
MakeIncludes=
Resources=
Compiler=
Linker=
IsCpp=1
Icon=
ExeOutput=
ObjectOutput=
OverrideOutput=0
OverrideOutputName=
Folders=
CommandLine=
Focused=0
Order=0,1

[Unit2]
FileName=Menu.h
Open=1
Folder=
Top=0
CursorCol=37
CursorRow=72
TopLine=1
LeftChar=1

[Unit1]
FileName=main.cpp
Open=1
Folder=
Top=1
CursorCol=39
CursorRow=105
TopLine=79
LeftChar=1

[Views]
ProjectView=1


------=_NextPart_000_0005_01C2D781.A27DC660
Content-Type: application/octet-stream;
	name="main.cpp"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
	filename="main.cpp"

#include <iostream>
#include <cstdlib>
#include <string>
#include "Menu.h"
//DEFINIZIONE FUNZIONI PER COMPORRE MENU

void prec() {}
void esci(void)
{
  cout << "Sto tornando al sistema.\n";
  system("PAUSE");
  exit (EXIT_SUCCESS);
}

void addizione(void)=20
{
cout << "immetti i numeri (double) da addizionare, quando terminato =
immettere 0\n";
double result=3D0;
double input=3D1;
while (input !=3D0)
    {cin >>input;
    result+=3Dinput;}
cout << "\nIl risultato e':    " << result;
}

void moltiplicazione(void)=20
{
cout << "immetti i numeri (double) da moltiplicare, quando terminato =
immettere 0\n";
double result=3D1;
double input=3D1;
while (input !=3D0)
    {cin >>input;
    result*=3Dinput;}
cout << "\nIl risultato e':    " << result;
}

void media(void)
{
cout << "immetti i numeri (double) di cui fare la media quando terminato =
immettere 0\n";
double result=3D0;
double input=3D1;
int count=3D0;
while (input !=3D0)
    {cin >>input;
    result+=3Dinput;
    ++count;
    }
cout << "\nIl risultato e':    " << result/count;
}

//FUNZIONE COMPOSER MENU

Opzione * riempiMenu(Menu* dariempire,int opz,void (**funzioni)(void))
{=20
for (int i=3D0; i< opz;i++)
 {
int scelta;
do {
    cout << "\n L'opzione e' un menu (1) o una azione? (2)\n";
    cin >> scelta;
    } while (scelta !=3D1 && scelta !=3D2);
if (scelta=3D=3D1){
        int opzn;
        string eti;
        cout << "\nImmetti etichetta menu e numero opzioni\n";
            cin >> eti >> opzn;
            Menu* temp=3Dnew Menu(eti,opzn+1);
            temp->defOpzione(new Azione ("menu precedente", prec, =
dariempire));
            dariempire->defOpzione( riempiMenu( temp,opzn, funzioni));
            }
    else {
        int funz;
        string azi;
        cout << "\nImmetti etichetta azione e numero funzione\n";
        cin >> azi;
        cin >> funz;
        dariempire->defOpzione(new Azione (azi, funzioni[funz], =
dariempire));
        }
  }    =20
return dariempire;
}


const int numeroFunc=3D3;


int main()
{
//PARTE DI CREAZIONE DEI MENU
void (*funzioni[numeroFunc])(void);
string nomifunc[numeroFunc];
funzioni[0]=3Daddizione; nomifunc[0]=3D"ADD";
funzioni[1]=3Dmoltiplicazione; nomifunc[1]=3D"MOLT";
funzioni[2]=3Dmedia; nomifunc[2]=3D"Media Aritmetica";
cout << "------------------------------------------------------\n";
cout << "|Lista funzioni disponibili per composizione menu";
cout << "|\n";
for (int i=3D0;i<numeroFunc;i++)
cout << "|    " << i << ") " << nomifunc[i] << endl;
cout << "-------------------------------------------------------\n";     =
   =20
//USO DEL MENU CREATO
int menuscelte;
cout << "Quante opzioni deve avere il menu principale?\n";
cin >> menuscelte;
Menu* princ=3Dnew Menu("MENU PRINCIPALE",menuscelte+1);
princ->defOpzione(new Azione ("Esci", esci, princ));
riempiMenu(princ,menuscelte,funzioni);
princ->attiva();
}


------=_NextPart_000_0005_01C2D781.A27DC660--