[qualsiasi]salti condizionali

[RaouL_BennetH]

Ciao a tutti

Mi sto sconfortando perchè non riesco ad organizzare in modo logico una serie di scelte che il programma dovrebbe fare in base a delle condizioni.

A prescindere dal tipo di linguaggio che sto utilizzando, ho difficoltà di questo tipo nel modo di pensare:

//devo prima verificare che determinati valori non siano nulli, per esempio:

if(valore1 != null)
{
   //istruzione
}
if(valore2 != null)
{
  //istruzione
}

Fin qui, tutto chiaro (come concetto)
Ora, però mi trovo ad affrontare una catena orrorifica di "if" dato che quando verifico il primo valore, poi devo anche verificare altri due `subvalori`, per es.:

if(valore1 != null && subvalue1 != null)
{
   //istruzione
}
if(valore1 != null && subvalue2 != null)
{
  //istruzione
}
if(valore1 != null && subvalue3 != null)
{
   if(subvalue2 > subvalue1)
   {
      //istruzione
   }
   else if(subvalue5 <= subvalue1)
   {
     //istruzione
   }
}

//etcetera...

Capisco da solo che è un modo orrendo di `pensare`.

Mi dareste una mano a migliorare?


Grazie mille


RaouL.

[andbin]

Originariamente inviato da RaouL_BennetH

Ora, però mi trovo ad affrontare una catena orrorifica di "if" dato che quando verifico il primo valore, poi devo anche verificare altri due `subvalori`

Capisco da solo che è un modo orrendo di `pensare`.

Mi dareste una mano a migliorare?

Beh, se è proprio quello che devi fare non è che ci siano molte altre strade .....
Al massimo visto che il test valore1 != null l'hai ripetuto più volte, potresti racchiudere tutto in un unico if (valore1 != null).

[71104]

ricorda che la validità dei parametri va verificata solo se provengono da fonti non fidate, come librerie esterne non del sistema operativo o dall'input dell'utente. mi sento di doverlo specificare perché al corso di programmazione 2 c'era una professoressa che diceva che i parametri delle funzioni vanno verificati SEMPRE (con anche il grassetto, o urlando a squarciagola se lo diceva a voce ), cosa palesemente falsa

[RaouL_BennetH]

Innanzitutto, grazie per le risposte

@ 71104: si tratta di input utente, quindi devo per forza di cose verificarne la validità

@ andbin: quindi dici che purtroppo non ho molte strade da seguire, ma credo che questo derivi dal fatto che non ho esposto troppo bene il problema Faccio un pò di `analisi` e poi sono sicuro che mi segnalerai al daily wtf

Mentre leggevo le vostre risposte, ho però pensato a:

e se usassi `switch\case` ?

[andbin]

Originariamente inviato da RaouL_BennetH

Mentre leggevo le vostre risposte, ho però pensato a:

e se usassi `switch\case` ?

Dipende da cosa devi testare. A seconda del linguaggio in genere lo switch è limitato a certi tipi di dati. Ad esempio in Java puoi usare solo byte/char/short/int (e i relativi wrapper) e gli enum, non certo stringhe o altri reference.

[71104]

Originariamente inviato da andbin

Dipende da cosa devi testare. A seconda del linguaggio in genere lo switch è limitato a certi tipi di dati. Ad esempio in Java puoi usare solo byte/char/short/int (e i relativi wrapper) e gli enum, non certo stringhe o altri reference.

anche boolean penso... ovvio però che non ha molto senso

switch (flag)
{
case true:
case false:
default:  // lol?
}

[andbin]

Originariamente inviato da 71104

anche boolean penso...

No, in Java non è ammesso nello switch.

[Fede_Reghe]

Potresti fare uno switch sulle sub, ma non avrebbe molto senso... Ti conviene usare gli if come hai fatto...

P.S: non è necessaria la default:

[^TiGeRShArK^]

public class ProvaIf {

	public ProvaIf() {
		String a = "";
		String b = null;
		String c = null;
		String d = null;
		if (a != null) {
			try {
				Class.forName("B" + b).newInstance();
				Class.forName("C" + c).newInstance();
				Class.forName("D" + d).newInstance();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}


	public static void main(String[] args) {
		ProvaIf p = new ProvaIf();
	}
}

public class Bnull {

	public Bnull() {
		System.out.println("B null");
	}
}

public class Cnull {

	public Cnull() {
		System.out.println("C null");
	}
}

public class Dnull {

	public Dnull() {
		System.out.println("D null");
	}
}

Ecco un esempio di come NON usare la reflection

[RaouL_BennetH]

Grazie a tutti per i suggerimenti, ma, tra poco dovrei aver finito l'horror code.

Quando lo termino, lo posto, in modo da essere sicuro di potervi far morire dal ridere per i prossimi 5 lustri

ma tipo fare una matrice/array di Method? (parlando di java)

[PGI-Bis]

Per sfruttare il collegamento dinamico deve prima ricondurre l'insieme di condizioni ad un identificatore. Un hashing, in pratica. Roba tipo:

actions.get(valore1, valore2, subValue1, subValue2, subValue3).execute();

Il "get" non deve essere definito tramite "if" o analoghi, se no è un barbatrucco.

Tutto sta nel trovare una funzione di hashing che riesca ad indentificare un'azione considerando non il valore assoluto dei parametri ma le loro disuguaglianze.

[RaouL_BennetH]

Ecco, adesso state cominciando a spaventarmi

[71104]

Originariamente inviato da pisto

ma tipo fare una matrice/array di Method? (parlando di java)

ma caro Andrea (), e come indici cos'hai intenzione di usare, i null?

Originariamente inviato da 71104

ma caro Andrea (), e come indici cos'hai intenzione di usare, i null?

se è una battuta non l'ho capita

[71104]

Originariamente inviato da pisto

se è una battuta non l'ho capita

cosa usi come indici per accedere agli elementi della matrice?

[PGI-Bis]

Originariamente inviato da RaouL_BennetH

Ecco, adesso state cominciando a spaventarmi

Non c'è nulla di cui spaventarsi .

Supponiamo un caso semplice. Cioè usiamo Java .

Hai due riferimento, a e b. Vuoi fare qualcosa in corrispondenza delle condizioni:

a != null e b != null
a == null e b == null
a = null e b != null
a != null e b = null

Non è bizzarro pensare, come ha fatto pisto, di avere un array di 4 oggetti, diciamo 4 Runnable (lasciamo da parte la riflessione ma si potrebbe usare anche quella per rendere l'ambaradan ancora più generico). I 4 Runnable nell'array sono indicizzati. Tutto quello che devi fare è stabilire un qualche genere di funzione che data una coppia di riferimenti trasforma l'unione dei loro valori in un numero intero da 0 a 3.

Ad esempio (molto teoricamente e detto da uno per cui la matematica è uno stato d'animo ):

int hash(Object valueA, Object valueB) {
    int hashA = System.identityHashCode(valueA);
    int hashB = System.identityHashCode(valueB);
    hashA = (3 * hashA) / (2 * hashA);
    hashB = (3 * hashB) / (2 * hashB);
    return hashA + 2 * hashB;
}

Basandoti su una comprovata (e non quella) funzione di hash che faccia quanto su detto, puoi creare senza difficoltà una struttura tipo:

public class DecisionMap {
	private static final class Condition {};
	public static final Condition NULL = null;
	public static final Condition NOT_NULL = new Condition();
	private Runnable[] runners = new Runnable[4];

	public void set(Runnable r, Condition valueA, Condition valueB) {
		runners[hash(valueA, valueB)] = r;
	}

	public void decide(Object valueA, Object valueB) {
		runners[hash(valueA, valueB)].run();
	}

	private int hash(Object a, Object b) {
		int hashOne = System.identityHashCode(a);
		int hashTwo = System.identityHashCode(b);
		hashOne = (3 * hashOne) / (2 * hashOne + 1);
		hashTwo = (3 * hashTwo) / (2 * hashTwo + 1);
		return hashOne + 2 * hashTwo;
	}
}

e usarla ad esempio:

public class Main {

	public static void main(String[] args) {
		class Printer implements Runnable {
			private String text;
			Printer(String text) { this.text = text; }
			public void run() { System.out.println(text); }
		}
		DecisionMap map = new DecisionMap();
		map.set(new Printer("null, null"),
			DecisionMap.NULL,
			DecisionMap.NULL);
		map.set(new Printer("null, not null"),
			DecisionMap.NULL,
			DecisionMap.NOT_NULL);
		map.set(new Printer("not null, not null"),
			DecisionMap.NOT_NULL,
			DecisionMap.NOT_NULL);
		map.set(new Printer("not null, null"),
			DecisionMap.NOT_NULL,
			DecisionMap.NULL);

		map.decide(null, "hello");
		map.decide(2, null);
		map.decide("hello", "world");
	}
}

Tutto sta nel ricondurre caratteristiche note a valori noti ed eseguire poi un calcolo dall'esito... noto L'arte di sapersi spiegare .

Non so quanto sia conveniente a livello di conti fatti dal PC. Ma se ti stanno antipatici gli if penso che l'unica alternativa sia l'hashing.

[lovaz]

E perché non togliere tutti i controlli e poi
catch di NullPointerException?

Certo bisognerebbe vedere il codice...

[71104]

@PGI-Bis: la versione con la matrice sarà anche più efficiente, ma obiettivamente quella con gli if occupa molte meno righe di codice... :|

[RaouL_BennetH]

Originariamente inviato da lovaz

Certo bisognerebbe vedere il codice...

mmm.. mi sa di no ... mi vergogno

Però tenete presente che sono un principiante, quindi siate comprensivi....

Premessa:

tutto questo casino che sto cercando di fare (ma con il solo scopo di iniziare a crearmi dei problemi e vedere se riesco a risolvermeli) nasce dal fatto ho un oggetto `griglia` composto da:

entrata1, uscita1, entrata2, uscita2, totale, totaleSingolo, Ordinario, Festivo, Notturno, TotaleEuroGiornaliero:

Ora.. devo fare in modo che :

1) se entrata1 ed uscita1 non sono vuoti, la cella corrispondente nella colonna 'totale' mi faccia un calcolo

2) se entrata2 e uscita2 non sono vuoti (ma sono vuoti entrata1 e uscita1), la cella corrispondente a totale mi faccia un altro calcolo

3) e non sono vuote tutte e quattro, mi faccia un calcolo fra uscita2 e uscita1.

4) se sono vuote tutte e quattro, devo vagliare solo totaleSingolo.

Inoltre... se:

1) Ordinario = 1; totaleGiornaliero faccia "totale (o totaleSingolo) * 6

2) Festivo = 1; vuol dire che ne Ordinario ne Notturno sono uguali a 1, e quindi devo fare: totaleGiornaliero = (totale o totaleSingolo) * 12

etc....

E ancora, appena una cella perde il focus, devo:

fare il parsing del testo immesso dall'utente e validarlo
se non è valido formattarlo..

dopodichè, ecco a voi il mio horror code:

//il programma è scritto in C#, ma credo che non sia scritto come se fosse C#



private void TestMethod(DataGridViewCellEventArgs e)

DateTime dt1, dt2, dt3, dt4;
bool b1, b2, b3, b4;

if(griglia.Rows[e.RowIndex].Cells[2].Value != null)
{
   for(int r = 3; r <= 12; r++)
   {
       griglia.Rows[e.RowIndex].Cells[r].ReadOnly = true;
   }
}

if(griglia.Rows[e.RowIndex].Cells[entrata1].Value != null &&
griglia.Rows[e.RowIndex].Cells[uscita1].Value != null)
{
   b1 = DateTime.TryParse(griglia.Rows[e.RowIndex].Cells[entrata1].Value, out dt1);

   b2 = DateTime.TryParse(griglia.Rows[e.RowIndex].Cells[uscita1].Value, out dt2);

   if( dt1 > dt2 )
   {
       TimeSpan ts = dt2.AddHours(24) - dt1;
       griglia.Rows[e.RowIndex].Cells[totale].Value = ts.ToString();
      
       if(griglia.Rows[e.RowIndes].Cells[Ordinario].Value != null)
       {
          griglia.Rows[e.RowIndex].Cells[totaleEuroGiornaliero].Value = (ts.Hours + (ts.Minutes / 60 )) * 6;

        }
        else if (griglia.Rows[e.RowIndex].Cells[Festivo].Value != null)
        {
           griglia.Rows[e.RowIndex].Cells[totaleEuroGiornaliero].Value = (ts.Hours + (ts.Minutes / 60)) * 12;
        }

//e questo solo nel primo caso e nel primo sottocaso in cui dt2 è < di dt1
//immaginate cosa sono riuscito a combinare per tutti i casi.... :D

}

Oltre ad una profonda vergogna che mi impone di non continuare a postare il codice..... vi prego di farmi letteralmente a pezzi senza nessuna pietà


RaouL.