Newsgroup: it.comp.lang.pascal
Titolo: azzerare un record

Ciao a tutti.
Volevo chiedervi se esiste un comando per rendere nulli tutti i campi di un
record.
Esempio :
dato  il record
TPippo = record
  campo1 : string;
  campo2 : integer;
  campo3 : real;
end;
esiste un modo per renderli nulli,
cioe' data la
var pippo : TPippo
che so,
pippo := nullo;
o e' necessario azzerarli uno a uno,
bisogna per forza fare
pippo.campo1 := '';
pippo.campo2 := 0;
ecc.??
RiCiao e... spero di essermi spiegato!! :)
Maurizio

 end;
nullo : Tpippo;
nullo.campo1:="";
nullo.campo2:=0;
nullo.campo3:=0;
var pippo : TPippo
pippo := nullo;
Dichiarando nullo come una costante, ma  alle 6.58 del mattino nn ricordo ne
se č possibile dichiarare un record costante ne la possibile sintassi
Ciao ReDiCuori

 ha scritto nel messaggio
news:qcvL8.9299$K4.1...@twister2.libero.it...

Si ti sei spiegato abbastanza bene.... è possibile ma francamente non so se
è sempre possibile in qualsiasi caso... io per mettermi al sicuro farei
cosi...
Supponendo di avere una definizione del tipo:
  Type Dato = Record
                         Info: String;
                         Num: Byte;
                       End;
  Var S: Dato;
In teoria se scrivi:     S := Null;    dovrebbe andare in quanto assegna
l'elemento neutro per ogni campo..... io non ho verificato quindi non posso
dire nulla... ma vado solo per logica.
Diversamente per mettersi al sicuro... svilupperei qualcosa del tipo:
Function Init: Dato;
 S: Dato;
 Begin
   With S Do
      Begin
        Info := '';
        Num := 0;
      End;
   Init := S;
 End:
Oppure se si vuole generalizzare....
Function Init (A: String;  B: Byte): Dato;
  Var S:
  Begin
    With S Do
      Begin
        Info := A;
        Num := B;
      End;
    Init := S;
  End;
In questo caso ovviamente bisogna dare:    S := Init ('',0);    per
inizializzare il tutto in una sola volta ma con la possibilità di inserire
il valore in qualsiasi momento.
Cordialmente, Cooper.

 Diversamente per mettersi al sicuro... svilupperei qualcosa del tipo:
mmh se per Null intendi nil, beh non funziona perche' Dato non e'
un puntatore, e se lo fosse lo renderesti non-valido perche' non
punterebbe piu' a nessuna struttura (idem in C, se il NULL veniva
da li...)  altrim il metodo del costruttore mi sembra il piu' saggio.
In caso di estremo bisogno di velocita' e generalizzazione forse
riempire di zeri la memoria dove si trova la struttura e' meglio:
qualcose del genere potrebe funzionare
procedure Zero( var mem; count : integer); assembler;
 asm
  les di,mem
  xor ax, ax
  mov cx,count
  cld
  rep stosb
 end;
chiamando Zero( <struttura>, sizeof (<struttura>) );
[per strutture di dime multipla di 2 si puo' ancora ottimizzare
  mettendo stosw al posto di stosb... per multiple di 4 penso
anche ma non so' come....albe ? :-) ]
(controllate sempre il mio asm... potrebbe fare cose strane !  :-) )
--
Dreadnaut
(Life would be easier if I had the source code)

 da li...)  altrim il metodo del costruttore mi sembra il piu' saggio.
A sě? NULL=NIL??
Sai in pascal non ho mai guardato come utilizzare l'allocazione dinamica
ecc.
Che bel.. 1 cosa in piů se č cossssě
Bye

> A sě? NULL=NIL??
beh non proprio identico... in C NULL e' una #define che vale 0,
quindi e' il "falso" in qualunque espressione:  come booleano, come
intero, come puntatore.
In pascal nil e' una parola chiave che indica un "puntatore indefinito"
e quindi non valido... non sono sicuro se sia zero oppure ffffffff
cmq una delle due :-).  E' solo un puntatore quindi, e in fondo il suo
valore non e' importate:   un puntatore o e' nil, o indica una posizione
in memoria.
Per l'allocazioni dinamica della mem, non ci sono molte differenze...
guardati le coppie  new/dispose (per oggetti/strutture/variabili)
e getmem/freemem (piu' comode per buffer (?), ma anche come
new/dispose)  ... per Mark e Release non ho mai trovato un uso
particolare... boh... in effetti sono un po' oscuri :-)


thanks...
Cereal

 se è possibile dichiarare un record costante ne la possibile sintassi
Sì, allora:
const
nullo:tpippo=(campo1:val1;campo2:val2;campo3:val3);
ma in realtà le const con tipo possono essere modificate(penso che le const
senza tipo non occupino spazio in memoria, come le #define del C, ma siano
sostituite diciamo "inline"(anche se non è una procedura, spero mi
capiate)).

Mark e Release marcano lo stato dell'heap per poi ripristinarlo; esempio:
mark all'inizio del programma, release alla fine, hai cosě alla fine la
garbage collection automatica in TP7! In pratica, dato che lo stato
dell'heap viene memorizzato in un puntatore, suppongo che l'heap venga
gestito come pila e che il puntatore contenga la fine dello spazio allocato.
Infatti, nei doc dice di non usare mark e release se si usano dispose o
freemem e viceversa, perché allora si potrebbe avere che una dispose crea un
buco nell'area continua allocata, uno spazio senza dati, e che release lo
dealloca di nuovo(se č stato allocato dopo mark) oppure pensa che ci siano
dati(se č stato allocato prima di mark) nel secondo caso forse non c'č
problema, nel primo sě.