variabler Datentyp

[vsilverlord]

hallo leute,
ich habe wieder das gleiche Problem wie neulich, mit dem Unterschied, dass das nun wirklich lösbar sein muss. Ich hab hier eine Routine, die eine Integer Zahl an eine Datei ranhängt, und nun möchte ich das so umschreiben, dass ich das für einen beliebigen Typ nutzen kann! (also auch für extended o.ä.)

Delphi-Quellcode:

procedure appandinteger(zahl: integer; path: string; Dateiname: string);
var
datei: file of integer;
begin
  AssignFile(datei, path+'\'+Dateiname+'.dat');
  if FileExists(path+'\'+Dateiname+'.dat') then ReSet(datei)
  else ReWrite(datei);

  Seek(datei, FileSize(datei));
  write(datei, zahl);
  CloseFile(datei);
end;

so würde ich das jetzt für extended machen, aber da das bis auf den typ das gleiche ist, würde ich das gerne generalisieren:

Delphi-Quellcode:

procedure appandextended(zahl: extended; path: string; Dateiname: string);
var
datei: file of extended;
begin
  AssignFile(datei, path+'\'+Dateiname+'.dat');
  if FileExists(path+'\'+Dateiname+'.dat') then ReSet(datei)
  else ReWrite(datei);

  Seek(datei, FileSize(datei));
  write(datei, zahl);
  CloseFile(datei);
end;

[s-off]

variant

[himitsu]

Oder überladene Prozeduren.

[Neutral General]

Hatte gerade an etwas wie generische Prozeduren gedacht, aber scheinbar gibt es soetwas nicht:

Delphi-Quellcode:

procedure AppendTo<T>(ADatei: String; AValue: <T>); 
var datei: file of <T>; 
begin 
  AssignFile(datei, ADatei); 
  if FileExists(ADatei) then ReSet(datei) 
  else ReWrite(datei); 

  Seek(datei, FileSize(datei)); 
  write(datei, zahl); 
  CloseFile(datei); 
end;

// Aufruf
AppendTo<Integer>('Test.txt',10);
AppendTo<String>('Test.txt','Hallo Welt!');

Warum eigentlich nicht? Wäre doch ganz praktisch in manchen Fällen..

[Uwe Raabe]

Es geht schon, nur etwas anders:

Delphi-Quellcode:

type
  TFile<T> = class
  public
    class procedure Append(zahl: T; const path: string; const Dateiname: string);
  end;

class procedure TFile<T>.Append(zahl: T; const path: string; const Dateiname: string);
var
  datei: file;
  fullName: string;
begin
  fullName := path+'\'+Dateiname+'.dat';
  AssignFile(datei, fullName);
  if FileExists(fullName) then begin
    Reset(datei, Sizeof(T));
    Seek(datei, FileSize(datei));
  end
  else begin
    Rewrite(datei, Sizeof(T));
  end;

  BlockWrite(datei, zahl, 1);
  CloseFile(datei);
end;

TFile<Integer>.Append(5, 'C:\temp', 'integer');
TFile<Extended>.Append(0.5, 'C:\temp', 'extended');

[SirThornberry]

Oder einfach einen Pointer verwenden und die Größe mitgeben.

[Neutral General]

Zitat von SirThornberry:

Oder einfach einen Pointer verwenden und die Größe mitgeben.

Dann am besten (weil bequemsten) als var-Parameter:

procedure AppendData(var Data; Size: Cardinal); Also quasi sowas wie Stream.Write.

[Uwe Raabe]

Zitat von Neutral General:

Zitat von SirThornberry:

Oder einfach einen Pointer verwenden und die Größe mitgeben.

Dann am besten (weil bequemsten) als var-Parameter:

procedure AppendData(var Data; Size: Cardinal);

Dann kann man aber keine Konstanten oder Funktionsergebnisse schreiben.

[Neutral General]

Geht beides auch mit

procedure AppendData(Data: Pointer; Size: Cardinal); nicht.

[himitsu]

Zitat von Uwe Raabe:

Dann kann man aber keine Konstanten oder Funktionsergebnisse schreiben.

Typisierte Konstanten sollten gehn, da sie ähnlich einer Variable verwaltet werden

Und notfalls kann man auch nachträglich typisieren

sowas müßte also gehn:

Delphi-Quellcode:

const s = '123';
  ts: String = '456';

function WriteS(var s);
...

function x: String;
...

WriteS(ts);
WriteS(String(s));
WriteS(String(x));

und hier würde man wohl das Resut kopieren und nicht einen Pointer ala @test:

Delphi-Quellcode:

function test: Integer;
MoveMemory(@i, @Integer(test), SizeOf(Integer));