150 MB Datei erstellen immer in 256byte schritten?

[R0BIN]

Also folgendes...

Ich möchte eine 150 MB große Datei erstellen, dabei sollen die ersten 256byte mit 1 gefüllt werden, die nächsten 256byte mit 2 u.s.w.

Wie mach ich das am einfachsten?

R0BIN

[Zacherl]

Guck dir mal TFileStream an ...

[R0BIN]

ok, ansich hab ich das verstanden:

Delphi-Quellcode:

procedure caststring;
var
  fs: TFileStream;
const
  s: string = '1';
begin
  fs := TFileStream.Create('dateia256.txt', fmCreate or fmOpenWrite);
  fs.Write(PChar(s)^, Length(s)); 
end;

Aber ich verstehe nicht wie ich genau 256byte als 1 und die nächsten als 2 und wieder die nächsten als 3 schreiben kann. Die Filegröße soll dabei dynamisch von mir zugewiesen werden können.

R0BIN

[Zacherl]

Ein Zeichen ist ein Byte ... du musst also nur in einer Schleife so lange Bytes in den Stream schreiben, bis die Dateigröße erreicht ist ...

Beispiel:

Delphi-Quellcode:

procedure caststring; 
var 
  fs: TFileStream; 
  s: string; 
  i: integer;
const
  FileSize = 157286400; //In Byte 1024 * 1024 * 150 = 150MB
begin 
  fs := TFileStream.Create('dateia256.txt', fmCreate or fmOpenWrite); 
  try
    for i := 1 to (FileSize div 256) do
    begin
      s := IntToStr(i);
      fs.Write(PChar(s)^, Length(s));  
    end;
  finally
    fs.Free;
  end;
end;

Florian

[R0BIN]

irgendwie funktioniert das nicht...die zahlen sind durcheinander und die datei ist keine 150mb groß!

hmm komisch!

[Zacherl]

Wie groß ist die Datei denn?

[Mackhack]

Die sollte nach deiner For-Schleife 150MB/256 gross sein. Ausserdem schreibst du ja nicht 1 256 mal rein dann 2 256 mal. Brauchst du doch 2 Schleifen um das zu machen. Die eine fuer die Anzahl der Zahlen die innere fuer die 256 mal der gleichen Zahl.

[Zacherl]

Sorry war mein Fehler, aber so sollte es gehen:

Delphi-Quellcode:

procedure caststring;
var 
  fs: TFileStream; 
  s: string; 
  i,
  i2: integer;
const
  FileSize = 1024; //In Byte 1024 * 1024 * 150 = 150MB
begin 
  fs := TFileStream.Create('C:\dateia256.txt', fmCreate or fmOpenWrite);
  try 
    for i := 1 to (FileSize div 256) do 
    begin
      s := '';
      SetLength(s, 256);
      for i2 := 1 to 256 do
        s[i2] := IntToStr(i)[1];
      fs.Write(PChar(s)^, Length(s));  
    end; 
  finally 
    fs.Free; 
  end; 
end;

@Mackhack: Ja, hatte es zwischenzeitlich auch schon gemerkt ... Sowas blödes :? ;)

Florian

[Mackhack]

Da war kein roter Kasten da :cry:

[Zacherl]

Mhh bei mir grade auch nicht ...

[R0BIN]

geht immer noch nicht wirklich....jetzt kommen 1 - 9 und dann aber wieder einsen bis neunen...

[inherited]

Sind ja auch Ferien :roll:

[Mackhack]

Zitat:

Zitat von R0BIN

geht immer noch nicht wirklich....jetzt kommen 1 - 9 und dann aber wieder einsen bis neunen...

Nur mal so: Fuer was brauchst du denn diese File?

[R0BIN]

für einen test...

[Zacherl]

Mist ... war doch falsch :? Das problem liegt hier:

Delphi-Quellcode:

for i := 1 to (FileSize div 256) do 
    begin 
      s := ''; 
      SetLength(s, 256); 
      for i2 := 1 to 256 do 
        s[i2] := IntToStr(i)[1]; 
      fs.Write(PChar(s)^, Length(s));  
    end;

Man kann nicht einfach schreiben:

Delphi-Quellcode:

for i := 1 to (FileSize div 256) do 
    begin 
      for i2 := 1 to 256 do 
        s := IntToStr(i); 
      fs.Write(PChar(s)^, Length(s));  
    end;

weil dann die Datei möglicherweise zu groß ist ...

[Christian Seehase]

Moin Zusammen,

wie wär's denn mit:

Delphi-Quellcode:

var
  sBuf   : string;
  i      : integer;

begin
  fs := TFileStream.Create(....);
  try
    while true do begin
      for i := 1 to 255 do begin
        sBuf := StringOfChar(chr(i),256);
        fs.Write(sBuf[1],256);
        if fs.Size = (1024*1024*150) then exit;
      end;
    end;
  finally
    FreeAndNil(fs);
  end;
end;

[Sunlight7]

Warum nimmst Du nicht einfach einen PChar, ZeroMemory, bzw. FillMemory und schreibst das direkt in die Datei, anstatt Dich mit den FileStreams herum zu ärgern? :gruebel:

Edit: Also wenn das mit dem Roten Kasten funktionieren würde, wäre das nicht schlecht...

[Mackhack]

Na ja jetzt hast ja wieder nur eine Schleife drin und nur noch 1024 als Filesize.

//Edit: Hat sich erledigt!

[R0BIN]

jetzt ist es wieder wie nach deinem ersten code!

[jmd anders]

Naja irgendwie kann das nicht so klappen. du deine 111.. 222... 333.. ...999... geschrieben hast, braucht ja jedes Zeichen im string wirklich nur ein byte, nur dann bei der 10 werden immer 2 bytes zur darstellung gebraucht und dann ab der 100 3 zeichen, also muss etwas an der aufgabenstellung geändert werden. müssen es unbedingt zahlen sein?

[R0BIN]

also bis jetzt hat noch keine möglichkeit so richtig funktioniert...

nein es müssen nicht unbedingt zahlen sein...nur unterschiedliche zeichen...

[Zacherl]

Das Konzept ist schwierig ... man müsste in die Schleife noch einberechnen, wie viele Bytes eine Zahl hat ...

[Mackhack]

Zitat:

Zitat von R0BIN

also bis jetzt hat noch keine möglichkeit so richtig funktioniert...

nein es müssen nicht unbedingt zahlen sein...nur unterschiedliche zeichen...

Dann mach 0-9 und a-z und A-Z dann kannst ja denk ich wieder von vorne anfangen!

[R0BIN]

ja das wäre ja kein thema 0-9 a-z A-Z aber wie schreibe ich die procedure?

[Sunlight7]

Hab gerade probiert, ist ganz leicht.
Wird der Source noch benötigt?

[R0BIN]

ja wäre echt nett wenn du den posten könntest!

[Flare]

Wieso missbraucht ihr dafür nicht einfach die ASCII-Zeichen? Die Zeichen 1-31 sollte man natürlich weglassen aber danach können doch alle genommen werden und es ist auch immer ein anderes Zeichen...


Flare

[Sunlight7]

Jo, no problemo.

Warum ärgert ihr euch immer mit den komischen FileStreams???

Delphi-Quellcode:

procedure TForm1.CreateMyFile;
   const MaxSize=150 * 1024 * 1024;
   var F:File;
       PC:PChar;
       c:Char;
       i:Integer;
   label DoItAgain;
begin
   GetMem(PC, 256);

   AssignFile(F, 'E:\Test.nix');
   ReWrite(F, 1);
DoItAgain:
      For c:='a' to 'z' do begin
         For i:=0 to 256-1 do
            PC[i]:=c;

         BlockWrite(F, PC^, 256);
         If FileSize(F)>=MaxSize then Break;
      end;
      If FileSize(F)<MaxSize then goto DoItAgain;
   CloseFile(F);

   FreeMem(PC);
end;

Geht doch ohne viel einfacher :???:

[R0BIN]

danke, das scheint zu gehen!

[Zacherl]

Und jetzt noch ohne Label:

Delphi-Quellcode:

procedure TForm1.CreateMyFile; 
   const MaxSize=150 * 1024 * 1024; 
   var F:File; 
       PC:PChar; 
       c:Char; 
       i:Integer; 
begin 
   GetMem(PC, 256); 

   AssignFile(F, 'E:\Test.nix'); 
   ReWrite(F, 1); 
   repeat
      For c:='a' to 'z' do begin 
         For i:=0 to 256-1 do 
            PC[i]:=c; 

         BlockWrite(F, PC^, 256); 
         If FileSize(F)>=MaxSize then Break; 
      end; 
      until FileSize(F)>=MaxSize; 
   CloseFile(F); 

   FreeMem(PC); 
end;

Florian

[Sunlight7]

@Florian: Schlaumeier :mrgreen: :mrgreen: :mrgreen:

Zitat:

Zitat von Robin

danke, das scheint zu gehen!

Nö, das scheint nicht, das ist so, habs probiert.

[Zacherl]

Zitat:

Zitat von Sunlight7

@Florian: Schlaumeier :mrgreen: :mrgreen: :mrgreen:

:mrgreen: Ich habs nicht gerne mit Labels, weil ich diesen Programmierstyl zu unübersichtlich finde ... bei einem gehts ja noch, aber wenn man dann hinterher 20 Label hat, wirds arg unübersichtlich ... aber dieses Thema hatten wir schon in einem anderen Thread ...

[Sunlight7]

Echt?
Hmm, ich hab höchstens 2 Labels, und die sind mir lieber, weils für mich übersichtlicher ist.

Aber ich will jetzt mal keine Diskussion anzettln.

[Zacherl]

Ja, bei zweien ist auch noch nicht schlimm finde ich, aber halt über 10 wirds schon arg unübersichtlich, deshalb vermeide ich labes, wo ich nur kann. :mrgreen: