Newsgroup: it.comp.lang.delphi
Titolo: Altri mondi - RPG e DS

Premessa: dopo parecchio tempo di programmazione Delphi, sono passato ad
AS/400 per necessità, e ho programmato in RPG... due linguaggi
diametralmente opposti, ma ovviamente certe volte viene spontaneo fare
paragoni o cercare metodi per fare le cose che un linguaggio può fare e
l'altro no... una di queste è la gestione delle DS (Data Structure).
Essenzialmente in RPG una DS è intesa come un record in Pascal, cioè una
definizione di tipi dati eterogenei che possono essere trattati sia
unicamente che separatamente.
Il bello però è che se noi abbiamo una "DS1" formata da:
campo1 - 6 alfanumerico
campo2 - 3.0 numerico
campo3 - 20 alfanumerico
in RPG si può fare un'operazione MOVE da una qualsiasi stringa alfanumerica
di qualsiasi dimensione a una DS di questo tipo, e poi potremo riferirci
alle variabili per campo... esempio:
MOVE     'ABCDEF1234567890GHILMNO'      DS1
avremo che
campo1 = 'ABCDEF'
campo2 = 123
campo3 = '4567890GHILMNO      '
e vi assicuro che è davvero una cosa utilissima.
Vengo finalmente al dunque: come fareste voi ad implementare questa cosa in
Delphi?
Secondo me sarebbe una cosa che semplificherebbe tantissime cose.
Se volete scrivermi: 
gare...@mindless.com
Jax

Guarda non ne ho idea, comunque posso dirti che anche il COBOL aveva questo
tipo di funzionamento, e concordo con te che è una cosa utilissima in vari
casi.
Oltretutto in COBOL c'era la REDEFINES che ti permetteva di vedere un certo
insieme di byte in N modi diversi, ad esempio:
CFISCALE CHAR(16)
potevi anche ridefinirlo e vederlo come
PIVA CHAR(11)
FILL CHAR(5)
questo era ancora più comodo.
Scusa se non ti rispondo, però mi hai fatto tornare in mente i vecchi
tempi....
Ciao
Paolo Pedrielli
Sintesi S.r.l.
EMail: 
pao...@sintesi.com
  ---  Web: 
http://www.sintesi.com
"Jax" <rispo...@newsgroup.grazie> ha scritto nel messaggio
news:zxVt7.20753$C15.2...@news.infostrada.it...


 e vi assicuro che è davvero una cosa utilissima....

Mah, concordo con te che č tanto bello quanto incapibile soprattutto se
penso a quanto tempo ci ho perso facendo un'utility di import dalle tabelle
AS (ANTA200F per l'esattezza - ACG) utilizzando le DS a seconda del tipo di
"tabellina" mi trovato.
Cmq se io dovessi cercare di risolvere il problema farei una cosa del genere
(ps: non l'ho provato, penso che si possa fare!):
supponi di avere un tipo record di questo genere:
Tmiorec = record
    nome: string[20];
    eta: smallint;
    provincia: string[4];
end;
function MiaMove(aString: string; var amiorec: Tmiorec);
var vI: integer;
begin
    vI := 1;
    amiorec.nome := copy(astring,vI,sizeof(amiorec.nome));
    vI := vI + sizeof(amiorec.nome);
    amiorec.eta := strtoint(copy(astring,vI,sizeof(amiorec.eta)));
    ecc...
    ecc...
end;
Magari non ho capito il tuo problema...oppure questa funzione non č
esattamente quello che volevi...
saluti
--
ciao
Solid Snake IT
"Nemo mortalium omnibus horis sapit" (Plinio il VECCHIO)

 partenza per una tecnica di programmazione appena decente.
Addirittura? Io invece le considero un po' inutili e pericolose, infatti tento
di starne alla larga quando posso... non so perché, ma non mi piacciono queste
forzature.
Jax


Ho lavorato prima in RPG ed ho usato le DS poi sono passato al Clipper e poi
a Delphi
(transitando un attimo attraverso Visual Object e molto di sfuggita Visual
Basic)
Delle Data Structure non sento assolutamente la mancanza!
E' un buon sistema di lavorare quando sei costretto a fare i salti mortali,
che ti evita una capriola.
Se ci pensi solo un attimo puoi fare la stessa cosa con la funzione copy e
le eventuali dovute conversioni di tipo.
Tuttavia se ti sforzi di avere i dati puliti e separati già alla fonte (e
quasi sempre si può) poi vivi più tranquillo che,
se per caso qualcosa va storto, hai potuto farti tutti i controlli
necessari.
Tutto questo "secondo me".
Ciao.
--
Emilio Panozzo
mailto: 
emip...@tin.it

 usato credo sia PChar(string) per passare i parametri alle API :))...
Attenzione, perchè non sempre è la stessa cosa. Una funzione di conversione
salva il *valore logico* di una variabile di un tipo in una variabile di un
altro tipo, il casting legge un *valore fisico* (cioè il contenuto della
locazione di memoria) secondo un tipo di dato diverso da quello originario.
Ad es:
var
  S1, S2 : string;
  I : integer;
begin
  I1 := 1972;
  S1 := StrToInt(I); // conversione da intero a stringa
  Label1.Caption := Concat('Il valore logico di I è: ', S1);
  S2 := shortstring(I); // casting di una stringa su un intero
  Label2.Caption := Concat('Il valore fisico nella locazione di I è
rappresentabile, come se fosse una stringa, così : ', S2);
end;
Come si vede la stessa variabile intera I viene presa in considerazione
prima per il suo valore logico (che viene poi restituito in una stringa),
poi per il suo valore fisico (ovvero il contenuto della locazione di
memoria). Questo valore fisico viene quindi letto in S2 *come se fosse una
stringa*. Che si tratti di cose diverse lo dimostra il diverso output
(visualizzato nelle label).
In delphi uno dei tipici usi del casting è la scrittura di event handler
generici. Ad es.
procedure TMainForm.Button1Click(Sender : TObject);
begin
  if (Sender is TButton) then
    TButton(Sender).Caption := 'Clicked!'; // casting di TButton su un
generico oggetto
// codifiche alternative possono essere
// with (Sender as TButton) do Caption := 'Clicked!;
// (Sender as TButton).Caption := 'Clicked!;
end;
Ora, nel corpo del codice appena visto non si fa riferimento ad alcun Button
particolare per cui, ammettendo che sulla form dove è posto il Button1 di
cui sopra ci siano altri 10 TButton, l'event handler appena visto può essere
scritto una sola volta e poi direttamente collegato ad ognuno dei TButton a
design time, per mezzo dell'object inspector. Tutte le codifiche elencate
mostrano dei sofisticati esempi di casting, possibili solo in delphi (non in
pascal), che offrono la gestione del meccanismo del casting con l'utile
accessorio della gestione degli errori da parte della VCL.
Queste argomentazioni dimostrano, a monte, una cosa di cui sono sempre stato
convinto: per essere un decente programmatore delphi è necessario avere un
solido e sperimentato background pascal.
