Newsgroup: it.comp.lang.delphi
Titolo: [Delphi] Info

Esiste un operatore condizionale simile a quello java ..
" condizione ? espressione 1  : espressione 2 "
grazie

potresti tradurlo x chi, come me, java non lo ha visto manco con un
telescopio?
A.


No. Usa if/then/else.
IceCream

 ha scritto nel messaggio
news:b05uk2$q3h$1...@newsreader.mailgate.org...




In Java, come in C e in C++, e` un operatore, l'operatore ?:, invece,
in Delphi esiste come funzione solo da Delphi 6, ma io consiglio di
non usare mai queste forme criptiche di codice.

telescopio?
Si usa anche in c++. 
Ai tempi lo chiamavamo "if diretto", e' un particolare modo di eseguire i confronti.
Lo amavo....
Questa è la struttura 
 (condizione)?(blocco true):(blocco false);
se la condizione e' vera viene eseguito il blocco true, altrimenti il blocco false.
Pero' puo' essere anche usato come funzione, cioe' puoi mettere
sPippo := (a==b ? "A è uguale B" : "A è diverso da B");
e prenderti il valore tornato dai blocchi, che puo' essere qulasiasi tipo.
esempi: 
(ulMaxBitHeight > ulMaxHeightFont) ? ulRet=ulMaxBitHeight : ulRet=ulMaxHeightFont;
fprintf (g_pxf, "%s);\n", g_pxFields[i1].m_bNullable ? "TRUE" : "FALSE");
Ciao Alberto,
Morde.
morde [at] programmer [.] net

Lo amavo....
Gia` un modo stupendo per scrivere codice incomprensibile, senza alcun
vantaggio prestazionale.

vantaggio prestazionale.
Scusa perche' incomprensibile?
Sul fatto delle prestazioni non voglio entrare in merito, ma per me un codice scritto usando 
l'if diretto è altrettanto chiaro quanto una struttura if-else.... 


l'if diretto è altrettanto chiaro quanto una struttura if-else.... 
Tu dici ?
Result := ContoCorrenteEsistente(N)?((SaldoConto(N) > 0) ? 1:
((Affidamento(N)>0) ? 1:0)):0
e` altrettanto chiaro di:
if (ContoCorrenteEsistente(N)) then
begin
  if (SaldoConto(N) > 0) then
  begin 
    Result := 1;               
  end
  else
  if (Affidamento(N)) then
  begin
    Result := 1   
  end
  else
    Result := 0;
end
else
  Result := 0;
-- 
Andrea Laforgia
"Meglio cieco che negro" (Stevie Wonder).

((Affidamento(N)>0) ? 1:0)):0
Ma sei andato a prendermi proprio un caso dove non è saggio
utilizzarlo! :-))
Questo in c++ per me si scrive:
int LaForgia::LaforgiaTest(void) {
 
   if (ContoCorrenteEsistente(N)) {  
      if (SaldoConto(N)) return 1;
      else if (Affidamento(N)) return 1;
      else return 0; 
   } 
   else  return 0;


utilizzarlo! :-))
Il problema e` che, a mio avviso, un costrutto del genere non e` *mai*
saggio utilizzarlo, in quanto comunque si rende il codice poco chiaro.


((Affidamento(N)>0) ? 1:0)):0
si ma bisogna anche usare le cose con un minimo di criterio.
(come con i break e gli exit che in op comunque esistono).
ciao
carlo

Salve,
vorrei dire la mia.
Tra i vari insegnamenti ricevuti, in tema di programmazione, rientra anche
la tecnica di scrivere codice sintetico. Poiché sono molto prolisso, un mio
caro professore riusciva sempre a ridurre in poche righe di istruzioni ciò
che io abbondantemente scrivevo. La cosa si sarebbe avantaggiata anche in
termini di maggiore velocità. Quindi, non capisco questa strana avversione
per istruzioni che possono consentire di accorciare codice senza perdere la
leggibilità. Almeno personalmente non mi sono mai confuso di fronte a
istruzioni simili a iif()
Ad ogni modo, ritengo azzardato stabilire quale procedura sia migliore di un
altra, quando queste raggiungono il medesimo risultato.
Ciao.
Toni

   Result := 0;
A dire il vero, personalmente faccio uguale fatica a leggere entrambi i
costrutti, il primo per l'eccessiva sinteticita' (l'uso di iif innestati
e' effettivamente ostico), il secondo per l'uso sovrabbondante di
begin...end
A parte il fatto che poteva essere scritto piu' semplicemente come
Result := EsisteConto(N) and ((SaldoConto(N) > 0) or (Affidamento(N) >
0));
Se proprio si vuole un risultato 0 o 1 si applichi ord all'espressione
sopra.
Il _bello_ di ? : e' che il valore dell'espressione non e' limitato ad
un boolean, un intero o un tipo semplice.
Saluti
Paolo Arosio

si ma bisogna anche usare le cose con un minimo di criterio.
Sicuramente, ma esistono costrutti che non aiutano a scrivere codice
nel migliore dei modi e quindi vanno evitati per quanto possibile.


un boolean, un intero o un tipo semplice.
Ribadisco che, a mio avviso, l'operatore ?:, che ho imparato a
scrivere e leggere nell'enormita` di righe di codice C/C++ che mi sono
passate tra le mani, non ha *alcun* vantaggio rispetto a if/then/else.


altra, quando queste raggiungono il medesimo risultato.
Proprio perche` due tecniche raggiungono lo stesso risultato si puo`
stabilire quali delle due sia la migliore.  Un confronto tra due
tecniche che raggiungono risultati diversi non ha senso.
Nel caso in questione, e` senz'altro meglio rinunciare alla
sinteticita` a favore della leggibilita` (anche perche` non impieghi
di certo meno tempo a scrivere un costrutto ?:, anziche` un
if/then/else), a beneficio di chi fara` manutenzione del codice (che
non e` affatto detto sia, nel tempo, chi ha scritto il programma).


 non e` affatto detto sia, nel tempo, chi ha scritto il programma).
Il tempo, di cui parlo, non è riferito a quello impiegato per la minutazione
ma alla velocità dell'eseguibile (che comunque resta trascurabile).
Mentre in merito alla leggibilità, non ho nessun
problema a comprendere codice altrui, anche se partorito dalla fantasia del
più imbranato programmatore.
Quindi sbizzaritevi pure...
Un cordialissimo saluto.   ;-)
Toni
"Meglio negro che cieco" (io).

problema a comprendere codice altrui
Sei fortunato.  In generale, non tutti possiedono questa tua dote
(che, comunque, e` messa tanto piu` in difficolta`, quanto maggiore e`
la complessita` del codice che stai esaminando) quindi e` bene
insegnare, a chi programma, che il codice va scritto in modo
leggibile, evitando quei costrutti che rendono, in generale, le cose
poco chiare.
-- 
Andrea Laforgia
#exclude <windows.h>

 panettone non ha molto senso.
Questo perchè tu non conosci il vino al panettone!
Provalo!
CiaooooOOO      :-)
Toni

 passate tra le mani, non ha *alcun* vantaggio rispetto a if/then/else.
Io lo rimpiango *solo* quando mi serve richiamare una funzione con un
parametro impostato in un modo piuttosto
che in un altro in base ad una condizione(molto semplice).
Ciao