Newsgroup: it.comp.lang.delphi
Titolo: questione di stile

Scusate la domanda all'apparenza stupida ma i NG servono anche per 
confrontarsi sulle piccole cose.
secondo voi e' meglio un
function xxx(A: Integer): Integer;
o
procedure xxx(var A: Integer)
va premesso che ovunque chiamo la funzione/procedura il parametro in 
entrata non viene piu' usato quindi puo' essere modificato.
Grazie in anticipo della risposta
Giuseppe

Giuseppe Monteleone ha scritto:

E' un fatto pratico, secondo me, nel senso che se usi la chiamata xxx(A) 
- senza null'altro - va benissimo la procedure, altrimenti se usi 
xxx(A)+Par1 o similari e' meglio la function
Per spiegarti meglio la procedure DEC del pascal ha senso solo come 
procedura, mentre, per esempio, la funzione ABS e' meglio che rimanga 
funzione in quanto la usero' insieme ad altre istruzioni sulla medesima riga

Microges ha scritto:

Ottima risposta, peccato che, pur avendo tutti gli elementi, non ci sia 
arrivato da solo ;-)
G.

entrata non viene piu' usato quindi puo' essere modificato.
Con una funzione puoi usare lo stile funzionale cioè utilizzare la
funzione come una variabile [3.14 +5* xxx(A)] oppure come input per
un'altra funzione [f(xxx(A)), dove f è una funzione o procedura).
Ma oltre lo stile, una chiamata ad una procedura è più efficiente di
quella ad una funzione.
jk
***
Jilani KHALDI
http://www.dotpas.org/cgi-bin/jkit/ii

 entrata non viene piu' usato quindi puo' essere modificato.
Ci sono casi in cui l'utilizzo di var al posto di un valore di ritorno
porta a significativi miglioramenti in termini di performance e
velocita'.
Puoi trovare maggiori dettagli al riguardo su questo mirror di
optimalcode.com
:
http://www.effovex.com/OptimalCode/
Per il resto, concodo con quanto scritto da Microges.
-- 
Vuoi distribuire il tuo sito web su CD/DVD?
Prova 
http://www.dwebpro.com/
Vuoi diventare un esperto analista Delphi?
Vieni a fare uno stage con noi: 
http://www.creativepark.it/stage/

entrata non viene piu' usato quindi puo' essere modificato.
Meglio la prima. Il passaggio per riferimento deve avere una
motivazione. Io preferisco la prima, ma ci sono casi di approcci
misti. E' tipico del C, per esempio. Ho scritto pochi giorni fa la
funzione seguente:
char *formatTime(time_t aTime, char *buf, size_t bufSize, const char
*format) 
{
    struct tm *ts;
    ts = localtime(&aTime); 
    strftime(buf, bufSize, format, ts);
    return buf;
}
particolarmente utile se si vuol trasformare in un buffer statico e
stampare allo stesso tempo.

procedura
Non è necessariamente vero. La funzione Dec() potrebbe benissimo
restituire il valore attuale o quello già decrementato.
Implementerebbe, in fin dei conti, quanto già presente in altri
linguaggi con, rispettivamente, l'operatore -- postfisso e prefisso.
Esempio Delphi:
var
  X: Integer;
  Tmp: Integer;
  function DecPre(var X: Integer; N: Integer = 1): Integer;
  begin
    X := X - N;
    Result := X;
  end;
  function DecPost(var X: Integer; N: Integer = 1): Integer;
  begin
    Result := X;
    X := X - N;
  end;
begin
  X := 5;
  Tmp := X;
  WriteLn('x = ', X);
  WriteLn('--x = ', DecPre(X));
  X := Tmp;
  WriteLn('x-- = ', DecPost(X));
  WriteLn('x = ', X);
  ReadLn;
end.
Output: 
x = 5
--x = 4
x-- = 5
x = 4
Esempio C:
[root@localhost ~]# cat > test.c
#include <stdio.h>
int main()
{
    int x = 5, tmp = x;
    printf("x = %d\n", x);
    printf("--x = %d\n", --x);
    x = tmp;
    printf("x-- = %d\n", x--);     
    printf("x = %d\n", x);
    return 0;
}
[root@localhost ~]# gcc test.c -o test
[root@localhost ~]# ./test
x = 5
--x = 4
x-- = 5
x = 4
[root@localhost ~]# 

 linguaggi con, rispettivamente, l'operatore -- postfisso e prefisso.
Perfettamente daccordo ma era per fare un esempio ;)

 
Io preferisco utilizzare la function perchè, anche in presenza di
elaborazioni sui dati che non prevedano necessariamente un ritorno, ho modo
di ottenere questi due vantaggi:
1 - avere sempre un controllo sul codice eseguito (tutto ok, ritorno 0)
2 - prepararmi al porting verso le DLL (utilizzo function con ritorno
double): sul progetto dove sono facciamo pesante uso di COM.
Ciao
-- 
Morde