Sapete proprio tutto sui record ?

[DragoRosso]

Ciao a tutti.

Volevo ricominciare a proporre delle "pillole" come diverso tempo fà ogni tanto si faceva.
L'argomento di oggi è legato ai record, ovviamente in Pascal.

Il record è un "oggetto" noto, usato, e stradocumentato.
In questa sede parliamo di record classici, non di quelli avanzati.

Provate a compilare questo programma:

Codice Seleziona Espandi

program Project1;

{$mode objfpc}{H+}

uses
  SysUtils;

type
  TTest = record
      Valore: integer;
  end;

  TClasseTest = class
    private
      FTest: TTest;
    public
      property Test: TTest read FTest write FTest;
  end;

var
  ClasseTest: TClasseTest;
begin
  ClasseTest := TClasseTest.Create;
  ClasseTest.Test.Valore := 2;
  ClasseTest.Free;
  Readln;
end.

Il codice è semplice, la classe espone una proprietà con cui si può leggere e scrivere il campo (una variabile) privata.
Avremo scritto una infinità di volte qualcosa di simile .... eppure ... adesso non riusciamo a compilare.

Perchè ?

Intanto, vi dò un aiuto, il fatto che FTest sia privato non c'entra. Inoltre non rispondete sul come si risolve, si può andare dal banale al più complesso ma talmente elegante che potremmo fare "funzionare" anche questa sintassi così come è ... ma non è questo il punto.

Il capire il perchè non si compila, e la descrizione di errore che fornisce fpc non è propria così delucidante ad un primo acchito, può essere utile ai meno smaliziati per comprendere meglio i record (e anche i meccanismi che si celano dietro una banale proprietà).

[quack]

Perché write accetta solo dati di tipo TTest, quindi di fatto sto accedendo a Valore tramite read.

Ma read restituisce una copia di FTest, anche senza l'errore del compilatore non potrei modificare la propietá Valore di FTest.
Questa è la spiegazione che mi sono dato dopo esserci incappato.

Se invece TTest fosse una classe funzionerebbe.
Ciao

[DragoRosso]

Bravo @quack, hai quasi centrato la risposta.

In realtà è più semplice e si basa sul concetto di "record" e delle sue operazioni instrinsiche.

L'assegnazione tra record viene fatto per valori e non per riferimento, cioè record a= record b significa che il contenuto di b viene copiato in a.
In questo caso per accedere al record, la proprietà deve prima leggerlo (getter / read), e quindi deve copiarlo (perchè l'assegnazione avviene per valori) in un record temporaneo ... in questo record il valore che deve essere assegnato non può essere scritto, perchè è un record temporaneo.
Da qui l'errore del compilatore "il valore a sinistra non può essere scritto".
Questo non avverrebe se l'accesso fosse diretto ad un altro tipo di variabile (anche managed) o ad una classe, perchè l'accesso sarebbe diretto senza necessità di fare copie temporanee.

L'uso della "proprietà" quindi deve essere ponderato in quanto ci possono essere "effetti secondari" che sfuggono al momento ma che possono creare alcune problematiche .. in questo caso sono palesi perchè non si compila, ma pensate se accadesse qualcosa solo a runtime invece ....

Così come bisogna ponderare bene l'uso dei record, tenendo conto delle loro specificità.

[cappe]

Codice Seleziona Espandi


program Project1;

{$mode objfpc}{H+}

uses
  SysUtils;

type
  TTest = record
      Valore: integer;
  end;

  TClasseTest = class
    private
      FTest: TTest;
    public
      property Test: TTest read FTest write FTest;
  end;

var
  ClasseTest: TClasseTest;
  t : TTest;
begin
  ClasseTest := TClasseTest.Create;
  t.Valore:=10;
  ClasseTest.Test := t;
  WriteLn(ClasseTest.Test.Valore);
  ClasseTest.Free;
  Readln;
end.   


Risultato 10

[cappe]

oppure, questo non se sia proprio corretto

Codice Seleziona Espandi


program Project1;

{$mode objfpc}{H+}

uses
  SysUtils;

type
  TTest = record
      Valore: integer;
  end;
  PTest = ^TTest;

  TClasseTest = class
    private
      FTest: TTest;
    public
      property Test: TTest read FTest write FTest;
  end;

var
  ClasseTest: TClasseTest;
begin
  ClasseTest := TClasseTest.Create;
  PTest(@ClasseTest.Test)^.Valore:=20;
  WriteLn(ClasseTest.Test.Valore);
  ClasseTest.Free;
  Readln;
end. 


[DragoRosso]

Risultato 10

Questo funziona perchè stai assegnando due record diretti, non accedi direttamente ad un campo del record Test do ClasseTest Se accedi al campo

Codice Seleziona Espandi

ClasseTest.Test.Valore := t.Valore;

dovrebbe riapparire l'errore teoricamente. Questo perchè il campo record Test.Valore deve prima essere letto temporaneamente. Nel caso di assegnazione diretta di un record dovrebbe essere fatta una copia integrale, senza quindi alcun passaggio temporaneo.

[DragoRosso]

oppure, questo non se sia proprio corretto
................

Si, il codice è corretto. Ma qui accedi tramite puntatore (deferenziato) e in questo modo elimini la gran parte dei check e le ottimizzazione del compilatore.

Mio consiglio (ma rimane mio personale ovviamente) è di non usare i puntatori, a meno che non sia strettamente necessario. In questo caso usando dei puntatori tipizzati, a differenza dell'uso dal cast, diciamo che possiamo lavorare con una certa sicurezza, ma il Pascal non c'è necessità in genere di usare i puntatori.

P.S.: siamo tutti d'accordo che dietro le quinte il compilatore lavora e genera le operazioni con i puntatori ... ma questo avviene per mano del compilatore, è diverso che forzare noi l'uso dei puntatori. In Delphi molte operazioni che involvono i puntatori vengono mascherate e la sintassi usata è come se l'operazione fosse fatta a livello di oggetto. Esempio tipico è l'assegnazione di un evento a runtime:

Codice Seleziona Espandi

//In FPC (modalita objfpc)
TControl.OnMouseMove := @MiaProcedura;

//In Delphi ( o FPC modalità Delphi)
TControl.OnMouseMove := MiaProcedura;

//Da notare la mancanza della @ in Delphi


[Lorenzo]

ma il Pascal non c'è necessità in genere di usare i puntatori.

Anche perchè di default abbiamo gli oggetti che sono puntatori ad oggetto e per come la vedo io non è cosa da poco perchè mi vedo una mano santa nella gestione della memoria.
Oltre a velocizzare di molto il codice.