Record, Object, Class. Warum nicht nur Object?

Für alles, was in den übrigen Lazarusthemen keinen Platz, aber mit Lazarus zutun hat.

Record, Object, Class. Warum nicht nur Object?

Beitragvon Soner » 14. Mai 2017, 17:22 Record, Object, Class. Warum nicht nur Object?

Ich habe heute Record, Object und Class-Typen näher angeschaut und eigentlich kann man mit Object die anderen beiden ersetzen.
Object-Typen können ohne Prozeduren und Funktionen wie Records benutzt werden dann sind die gleich schnell wie Records (beim erstellen, benutzen und freigeben).
Kleinere Objekte muss man nicht mal erstellen, man kann es einfach als VAriable definieren und benutzen.
Man kann ein Object auch wie Klassen benutzen, dann sind sie genauso schnell/nutzbar wie Klassen (class-Objekte).

Ist es nicht besser wegen einfachheit Records und Klassen zu verzichten und nur noch Object-Typen zu benutzen?

Hier habe ich ein Test für erstellen, "benutzen" und freigeben:
Code: Alles auswählen
 
Type            erstellt        benutzt         freigegeben in ms
...
======================
Testreihe 7
TObj            2.312846        0.091706        0.972155
TObjRec         0.906797        0.157406        0.812354
TRec            0.916379        0.092048        0.822277
TClass          2.286156        0.093417        1.145644
======================
Testreihe 8
TObj            2.336800        0.091706        0.972155
TObjRec         0.882502        0.091706        0.788743
TRec            0.912615        0.092391        0.796955
TClass          2.303950        0.100945        1.167202
======================
Testreihe 9
TObj            2.315584        0.091364        0.972155
TObjRec         0.907824        0.091706        0.794218
TRec            0.890372        0.091706        0.796955
TClass          2.303265        0.093075        1.145302
======================
Testreihe 10
TObj            2.311136        0.091364        1.004321
TObjRec         0.963943        0.091364        0.788743
TRec            0.914668        0.092048        0.796955
TClass          2.274864        0.093075        1.146329
 


Das ist das Programm das ich verwendet habe zum Testen:
Code: Alles auswählen
 
program ObjClassRecordDemo;
uses windows;
type
 
  { TObj }
  TObj = object
    X: integer;
    constructor Init;
    destructor Done;
  end;
  PObj = ^TObj;
 
  TObjRec = object
    X: integer;
  end;
  PObjRec = ^TObjRec;
 
  TRec= record
    x: integer;
  end;
  PRec=^TRec;
 
  TClass = class
    X: integer;
    constructor Create;
  end;
 
{ TObj }
constructor TObj.Init;
begin
  X:=1;
end;
 
destructor TObj.Done;
begin
end;
 
{TClass}
constructor TClass.Create;
begin
  X:=1;
end;
 
const ObjCount = 30000;
var //myObj: PObj;
    ObjList: array[0..ObjCount-1] of PObj;
    ORList: array[0..ObjCount-1] of PObjRec; //wie record erstellen
    RecList: array[0..ObjCount-1] of PRec;
    ClassList: array[0..ObjCount-1] of TClass;
    erstellt, benutzt, freigeg: single;
 
    i, reihe: integer;
var
  aFreq: Int64;
  aStart: Int64;
  aEnd: Int64;
begin
  QueryPerformanceFrequency(aFreq);
  Writeln('Type',#9#9,'erstellt',#9,'benutzt',#9#9,'freigegeben in ms');
  for reihe:=1 to 10 do begin
    WriteLn('Testreihe ',reihe,#13);
    // TObj
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      New(ObjList[i],Init);
    end;
    QueryPerformanceCounter(aEnd);
    erstellt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      if ObjList[i]^.X=1 then ObjList[i]^.X:=10;
    end;
    QueryPerformanceCounter(aEnd);
    benutzt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      Dispose(ObjList[i],Done);
    end;
    QueryPerformanceCounter(aEnd);
    freigeg:=((aEnd - aStart) * 1000 / aFreq);
    Writeln('TObj ',#9#9,erstellt:3:6,#9,benutzt:3:6,#9,freigeg:3:6);
 
    // TObjrecord
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      New(ORList[i]);
      ORList[i]^.X:=1;
    end;
    QueryPerformanceCounter(aEnd);
    erstellt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      if ORList[i]^.X=1 then ORList[i]^.X:=10;
    end;
    QueryPerformanceCounter(aEnd);
    benutzt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      Dispose(ORList[i]);
    end;
    QueryPerformanceCounter(aEnd);
    freigeg:=((aEnd - aStart) * 1000 / aFreq);
    Writeln('TObjRec ',#9,erstellt:3:6,#9,benutzt:3:6,#9,freigeg:3:6);
 
    // REcord ==================
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      New(RecList[i]);
      RecList[i]^.x:=1;
    end;
    QueryPerformanceCounter(aEnd);
    erstellt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      if RecList[i]^.X=1 then RecList[i]^.X:=10;
    end;
    QueryPerformanceCounter(aEnd);
    benutzt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      Dispose(RecList[i]);
    end;
    QueryPerformanceCounter(aEnd);
    freigeg:=((aEnd - aStart) * 1000 / aFreq);
    Writeln('TRec ',#9#9,erstellt:3:6,#9,benutzt:3:6,#9,freigeg:3:6);
 
 
    // Class ==================
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      ClassList[i]:=TClass.Create;
    end;
    QueryPerformanceCounter(aEnd);
    erstellt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      if ClassList[i].X=1 then ClassList[i].X:=10;
    end;
    QueryPerformanceCounter(aEnd);
    benutzt:=((aEnd - aStart) * 1000 / aFreq);
 
    QueryPerformanceCounter(aStart);
    for i:=0 to ObjCount-1 do begin
      ClassList[i].Free;
    end;
    QueryPerformanceCounter(aEnd);
    freigeg:=((aEnd - aStart) * 1000 / aFreq);
    Writeln('TClass ',#9#9,erstellt:3:6,#9,benutzt:3:6,#9,freigeg:3:6);
 
    WriteLn('====================== ');
  end; //von reihe
 
  WriteLn('[Enter] druecken zum Beenden.'); readln;
end.
 
Soner
 
Beiträge: 290
Registriert: 26. Sep 2012, 23:07
Wohnort: Hamburg
OS, Lazarus, FPC: Win7Pro-32Bit, Immer letzte Lazarus Release mit SVN-Fixes | 
CPU-Target: 32Bit
Nach oben

Beitragvon Euklid » 14. Mai 2017, 22:14 Re: Record, Object, Class. Warum nicht nur Object?

Also ich gehe sehr gerne mit Records um, weil die sehr schlank und ungeheuer einfach in der Handhabung sind.

Viele Grüße, Euklid
Euklid
 
Beiträge: 2754
Registriert: 22. Sep 2006, 09:38
Wohnort: Hessen

Beitragvon mse » 15. Mai 2017, 08:08 Re: Record, Object, Class. Warum nicht nur Object?

Soner hat geschrieben:Ich habe heute Record, Object und Class-Typen näher angeschaut und eigentlich kann man mit Object die anderen beiden ersetzen.

Einverstanden, siehe auch wie Objekte in MSElang implementiert wurden:
viewtopic.php?f=53&t=10729
mse
 
Beiträge: 1416
Registriert: 16. Okt 2008, 09:22
OS, Lazarus, FPC: Linux,Windows,FreeBSD,(MSEide+MSEgui 4.4,git master FPC 3.0,fixes_3_0) | 
CPU-Target: x86,x64,ARM
Nach oben

Beitragvon mschnell » 15. Mai 2017, 09:30 Re: Record, Object, Class. Warum nicht nur Object?

Die mse-Implementierung kommt mir sehr gut vor ! Explizite Typ-Namenen für Record, Object und Class sind definitiv nicht nötig, wenn der gemeinsame Type flexibel genug ist (siehe der von mse angegeben Link).

Die Namens-Gebung finde ich aber kritisch. Für mein Begriffe hat sich - unabhängig von der jeweiligen Sprache und anders als in Turbo-Pascal - "Klasse" als Typ und "Objekt" als Instanz eins solchen Typs eingebürgert.

-Michael
mschnell
 
Beiträge: 3110
Registriert: 11. Sep 2006, 09:24
Wohnort: Krefeld
OS, Lazarus, FPC: svn (Window32, Linux x64, Linux ARM (QNAP) (cross+nativ) | 
CPU-Target: X32 / X64 / ARMv5
Nach oben

• Themenende •

Zurück zu Sonstiges



Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

porpoises-institution
accuracy-worried