Newsgroup: it.comp.lang.pascal
Titolo: Record ??

Ueee a tutti !!!
C'č qualcuno che saprebbe spiegarmi (brevemente [se č possibile]) cosa
sono e come funzionano i record ??
Se le cose da dire sono molte e sarebbe una cazzata tentare di
riassumerle in poche righe indirizzatemi pure a qualche altra
fonte....tipo sito web, se neanche questo č possibile ...mandatemi a
quel paese =:-)
Fate con calma che tanto non riesco + a installare il compilatore :(
Ma maeglio non pensarci......porca *********
DeV
super...@iol.it
"L'ordine č la virtů dei mediocri "

 "L'ordine è la virtù dei mediocri "
Beh!in poche parole un record è usa struttura dati che contiene (dati)
elementi di tipi diversi.
Una persona potrebbe essre un record composto da 3 campi:
nome cognome ed aspetto fisico o qualcosa di simile.
In pascal i record sono utilissimi quando si vogliono gestire strutture dati
complesse definite dall'utente, nelle quali i vari campi possono essere un
qualsiasi altro tipo di dato (anche a sua volta un record).
In Pascal potresti definire una persona come
type
    persona=record
        nome,cognome:stringa;
        aspetto_fisico:record
                altezza:integer;
                capelli:(rossi,,,,,,,,,,,,...neri)
ecc.............
Se hai dei dubbi e/o/vuoi saperne di più scrivimi.

sono e come funzionano i record ??
Un record e' un tipo di dato.
Non e' elencato tra quelli primitivi, in quanto e' un tipo di dato
"composto".
L'unico modo di sfruttarlo, cioe', e' quello di costruirlo.
Puoi vedere un record come un insieme che racchiude piu' variabili
(che a loro volta possono essere record), chiamati "campi del record".
Per farti un esempio, una data puo' essere vista come un record
contenente giorno, mese e anno.
Un punto dello spazio come un record contenente le tre coordinate x,
y, z.
Una persona come un record contenente il nome, il cognome e un altro
record data che contiene giorno, mese e anno di nascita.
In Pascal e' possibile definire i tipi record nel modo seguente :
type mio_record = record
                    variabile1 : ...tipo... ;
                    variabile2 : ...tipo... ;
                    ...
                  end ;
Per esempio, una data e' definibile come :
type tipo_data = record
                   giorno : integer ;
                   mese   : integer ;
                   anno   : integer ;
                 end ;
Un punto come :
type tipo_punto = record
                    x : real ;
                    y : real ;
                    z : real ;
                  end ;
E ancora, una persona come :
type tipo_persona = record
                      nome         : string [20] ;
                      cognome      : string [30] ;
                      data_nascita : record
                                       giorno : integer ;
                                       mese   : integer ;
                                     end ;
                    end ;
Queste definizioni non comportano alcuna riserva di memoria, ma
servono ad indicare al compilatore che esistono tre tipi nuovi da
poter sfruttare.
Il tipo record puo' essere utilizzato alla stregua di un tipo
primitivo ed e' per questo che in un programma si puo' dichiarare :
var vettore : array [1..10] of tipo_data ;
    persona : tipo_persona ;
    coordinate : array [1..100] of tipo_punto ;
...
Non solo, ma in virtu' di questo principio, si puo' riscrivere il tipo
"tipo_persona" come :
type tipo_persona = record
                      nome         : string [20] ;
                      cognome      : string [30] ;
                      data_nascita : tipo_data ;
                    end ;
(Sempre che la definizione del tipo "tipo_data" avvenga prima di
"tipo_persona" in modo che il compilatore riconosca effettivamente il
primo tipo come un *nuovo* tipo).
Nel mio programma, allora, potro' accedere ai dati (campi) contenuti
in un record mediante l'operatore ".", il quale ha precedenza maggiore
di tutti gli altri, nel modo seguente :
vettore[2].x = 4 ;
...
writeln ( persona.nome ) ;
...
if ( persona.data_nascita.mese = 12 ) then writeln ('Ariete' ) ;
...
h = coordinate [4].x + coordinate[4].z / 100.0 ;
e cosi' via...
Nota come l'operatore "." puo' applicarsi in maniera ricorsiva (in
"persona.data_nascita.mese" ).
Inoltre, i record possono essere definiti al momento, senza ricorrere
necessariamente alla definizione di un nuovo tipo, semplicemente
scrivendo :
var vettore : array [1..10] of record
                                 giorno, mese, anno : integer ;
                               end ;
...
    persona : record
                nome : string [20] ;
                cognome : string [30] ;
                data : record
                         giorno : integer ;
                         mese, anno : integer ;
                       end ;
              end ; 
...
    coordinate : array [1..100] of record
                                     x, y, z : real  ;
                                   end ;
Ci sarebbe da aggiungere la possibilita' di definire dei record con
campi di tipo variabile, ma temo che complicherei le cose.
Concludo dicendo che il concetto di record e' molto importante, in
quanto la sua comprensione pone le basi per la comprensione della
programmazione orientata agli oggetti, in cui le classi, strutture
portanti, non sono altro che un'evoluzione dei record.

io con i record sono riuscito a cancellarmi mezzo hd
ma ancora non ho capito come è successo.
sono proprio un somaro...

Le vostre risposte a DeV sui record sono state molto utili anche a me e mi
hanno chiarito molte cose sul loro utilizzo. Quello che però non riesco
ancora a capire è preché sono tanto utili?
Scusate l'ignoranza ma sono nuovo nel guppo.
Spero che mi aiuterete.
Ciao!

ancora a capire è preché sono tanto utili?
I record sono sicuramente, unitamente ai puntatori, i tipi di dati
piu' utili ed importanti del linguaggio pascal (ed in generale di ogni
linguaggio ad alto livello) per la semplice possibilita' di
implementare tramite essi le strutture dati piu' importanti, come le
liste, le code, gli alberi, ecc...ecc...
Tale concetto e' ancora piu' esaltato nei linguaggi orientati agli
oggetti, che si fondano, in pratica, su evoluzioni dei record,
chiamate classi.
In generale, l'uso dei record congiuntamente ai puntatori e' ideale
per rappresentare strutture dati definite in modo ricorsivo.
Per esempio, consideriamo una lista.
Una lista e' definita in questo modo :
"Una lista e' un atomo vuoto o che punta a una lista".
Un'albero e' definito invece come :
"Un albero e' un atomo vuoto o che punta ad un numero definito di
alberi".
La rappresentare di una lista di interi, in Pascal, e' la seguente :
type PuntatoreNodoLista = ^NodoLista ;
     NodoLista = record
                   Dato                  : integer ;
                   PuntatoreProssimoNodo : PuntatoreNodoLista ;
                 end ; 
Come vedi, ogni atomo e' rappresentabile unicamente come record.
Nel caso di un albero di stringhe, si applica lo stesso principio :
type PuntatoreNodoAlbero = ^NodoAlbero ;
     NodoAlbero = record
                    Dato                  : string [20] ;
                    PuntatoreSottoAlbero1 : PuntatoreNodoAlbero ;
                    PuntatoreSottoAlbero2 : PuntatoreNodoAlbero ;
                    PuntatoreSottoAlbero3 : PuntatoreNodoAlbero ;
                    ...
                    PuntatoreSottoAlberoN : PuntatoreNodoAlbero ; 
                  end ;

 alberi".


sono risultate, per me, comletamente oscure e incomprensibili.

Inoltre, se io creo un record in questo modo:

type tipo_persona = record

                                  
nome         : string [20] ;

                                  
cognome      : string [30] ;

                              
end;

var persona : tipo_persona ;

Mi sembra di essermi comlicato la vita perché non ho fatto altro
che allungare il nome delle variabili.

Infatti quando dovrò utilizzare "nome" o "cognome" in qualsiasi
operazione, come ad esempio assegnazioni o "write", dovrò scivere:

persona.nome:= 'Fabio';

persona.cognome:= 'Feuli';

writeln(persona.nome);

write(persona.cognome);

Se invece non avessi usato nessun record, avrei scritto così:

var nome, cognome : string[20];

e per richiamarli in una qualsiasi operazione avrei scritto:

nome:= 'Fabio';

cognome:= 'Feuli';

writeln(nome);

write(cognome);

Perché dunque è conveniente usare i record?

Ciao!


>Perché dunque è conveniente usare i record?
La convenienza di utilizzo dei record l'ho gia' ampiamente spiegata
nei messaggi precedenti.
Se non conosci le strutture dati dinamiche ti consiglio di cominciare
a studiarle.
Io davo per scontato che le conoscessi in quanto fanno parte del
normale bagaglio di informazioni di ogni programmatore.
L'utilizzo di variabili separate come hai fatto tu e' sempre
sconveniente per motivi di "information hiding" (sarebbe troppo lungo
entrare nel merito) e si tende ad inglobarle in un'unica struttura.
Inoltre, considera di voler creare un vettore contenente le
informazioni relative ad ogni persona, ovvero il nome, il cognome, la
data di nascita, ...
Utilizzare dei vettori separati e' molto scomodo.
E' strano, comunque, a meno che programmi da poco tempo, che finora tu
non abbia sentito la necessita' di utilizzare i record.

 
Ci aggiungerei anche un "prova a scrivere in un file tante persone"... :-)
bye!
-- 
Emanuele Cesena                 
http://www.penguinpowered.com/~ecesena
ece...@penguinpowered.com
                 Attenti all'antispam NOSPAM
"Il governo si espande fino ad assorbire tutti i redditi, e poi ancora un
po'", legge di Wiker

 non abbia sentito la necessita' di utilizzare i record.
Infatti io ho appena finito il IV liceo scientifico e programmo in TP da
soli 4 anni. Considera che il livello di programmazione che ci forniscono
a scuola č bassissimo (per molti č gią tanto fare un programma che scriva
"ciao!" sullo schermo) e sono costretto ad andare avanti da solo: per
questo mi sono inscritto a questo gruppo!