[Corsopoc] Esercizio 3 non ho capito niente[long]

[Emanuele Di Saverio]

This is a multi-part message in MIME format.

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

Non ho capito come si fa a costruire un menu che abbia come opzioni
l'accesso ai sottomenu.
Nell'esempio dei lucidi si dava solo la
defOpzione( new Azione (stringa, funzioneptr,opzioneptr));
dove opzioneptr è il menu da richiamare alla fine di Azione.
Per passare al sottomenu, io ho trovato solo due metodi: chiamare defOpzione
(una azione che
non fa niente (fprt= funzione vuota(non NULL!)) e come opzione ptr il menu
che voglio
raggiungere, oppure chiamare direttamente
defOpzione(menuchevoglioraggiungerePTR) che tanto funziona uguale in quanto
l'array di puntatori è di tipo Opzione*?
I due modi presuppongono una chiamata
Menu* menuchevoglioraggiungerePTR= new Menu("sottomenu", numopzioni);
che allochi dinamicamente un sottomenu.
Devo essermi perso qualcosa perchè non ho afferrato...
Cmq la classe riveduta e corretta la posto per chi vuole vedersela (attenti
ai puntatori a funzione, void * f() è una funzione che restituisce void;
void  (*f)() è un puntatore a una funzione che restituisce void.)
E' quasi uguale a quella dei lucidi.
Il main.cpp invece l'ho tutto cancellato e ho rifatto come *penso* che si
debba usare la classe, con un semplice menu+ sottomenu che chiama una
funzione. Notare che la funzione  prec non fa assolutamente nulla! La uso
per le opzioni "menu precedente", alle quali passo non il puntatore al
sottomenu corrente, MA quelle del soVramenù. La cosa è MOLTO intricata
datemi una mano mi sto complicando la vita.Ditemi se mi sono perso qualcosa

Grazie!
Buon Natale a tutti!


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

------=_NextPart_000_000D_01C2AA98.B39F2EE0
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() {
  delete listaOpzioni;
}
=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_000D_01C2AA98.B39F2EE0
Content-Type: application/octet-stream;
	name="main.cpp"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
	filename="main.cpp"

#include <iostream>
#include <cstdlib>
#include <iostream>
#include "Menu.h"

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

void risolviJacobiPesato(void) 
{
cout << "JacobiPesato\n";
}

void prec() {}

int main()
{
Menu principale("Menu principale: ", 3);
principale.defOpzione(new Azione ("Torna al DOS",esci, &principale));
Menu* temp=new Menu("sottomenu",2);
temp->defOpzione(new Azione ("Jacob", risolviJacobiPesato, temp));
temp->defOpzione(new Azione ("menu precedente", prec, &principale));
principale.defOpzione(new Azione ("sottomenutemp" , prec, temp));
//oppure principale.defOpzione(temp) che fa lo stesso
principale.defOpzione(NULL);
//prova per una Opzione NULLa
principale.attiva();
}


------=_NextPart_000_000D_01C2AA98.B39F2EE0--