Bytes in GB formatieren?

[mlspider]

Ich benötige die Ausgabe des freien Speicherplatzes eines gewählten Laufwerkes. Erledigt wird dies wie folgt:

Delphi-Quellcode:

function GetDiskSize(drive: Char; var free_size, total_size: Int64): Boolean;
var
RootPath: array[0..4] of Char;
RootPtr: PChar;
current_dir: string;
begin
RootPath[0] := Drive;
RootPath[1] := ':';
RootPath[2] := '\';
RootPath[3] := #0;
RootPtr := RootPath;
current_dir := GetCurrentDir;
if SetCurrentDir(drive + ':\') then
begin
GetDiskFreeSpaceEx(RootPtr, Free_size, Total_size, nil);
SetCurrentDir(current_dir);
Result := True;
end
else
begin
Result := False;
Free_size := -1;
Total_size := -1;
end;
end;

Der Aufruf:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
s: String;
free_size, total_size: Int64;
begin
s := ExtractFileDrive(ParamStr(0));
showmessage(s[1]);


if GetDiskSize(s[1], free_size, total_size) then

ShowMessage('free space =' +
IntToStr(free_size) + #13 + 'total size=' +
IntToStr(total_size))
else
ShowMessage('Keine Disk im Laufwerk!');
end;

liefert das Ergebnis in Byte. Ich möchte beide Werte in GB formatieren. Aber wie?

[TeronG]

N paar (3) mal duch 1024 teilen!?

(und evtl. mit RoundTo noch n bissl "Pimpen")

[Phoenix]

Bytes / 1024 = KBytes
KBytes / 1024 = MBytes
MBytes / 1024 = GBytes

x Bytes / 1024 / 1024 / 1024 = y GBytes

[stahli]

1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB

Stahli

PS: Ich war zu langsam, aber auch gut ;-)

[Angel4585]

*am langsamsten bin*

2^10=Kilo
2^20=Mega
2^30=Giga
usw...

[mlspider]

Delphi-Quellcode:

IntToStr(free_size div 1024 div 1024 div 1024) + #13 + 'total size=' +
IntToStr(total_size div 1024 div 1024 div 1024))

gibt mir zu ungenaue Angabe. Wie soll ich RoundTo anwenden?

[Phoenix]

Div schmeisst ja auch die Nachkommastellen weg - und wenn Du dreimal durch ~1000 Teilst wird die Zahl kleiner und damit werden die Nachkommawerte wichtiger.

Teile doch einfach echt mit:

Delphi-Quellcode:

free_size / (3* 1024)

und benutze FloatToString um den Wert dann mit ein paar Nachkommstellen zu formatieren.

[mlspider]

Delphi-Quellcode:

ShowMessage('free space =' +
IntToStr(free_size / (3* 1024)) + #13 + 'total size=' +
IntToStr(total_size))

gibt einen Compilerfehler aus:

Es gibt keine überldene Version von IntToStr, die man mit diesen Argumenten aufrufen kann.

[Die Muhkuh]

Zitat:

Zitat von Phoenix

und benutze FloatToString um den Wert dann mit ein paar Nachkommstellen zu formatieren.

[Angel4585]

Zitat:

Zitat von Phoenix

Teile doch einfach echt mit:

Delphi-Quellcode:

free_size / (3* 1024)

:shock: Warum soll er durch 3072 teilen? :gruebel:

[Die Muhkuh]

Dreimal geteilt durch 1024 ergibt ein GB (wenn man mit einem Byte anfängt)

[mlspider]

Delphi-Quellcode:

FloatToStr(free_size / (3* 1024)) + #13 + 'total size=' +
FloatToStr(total_size / (3* 1024)))

Bringt zwar keinen Compilerfehler, dafür aber falsche Werte.

[Phoenix]

Zitat:

Zitat von Angel4585

Zitat:

Zitat von Phoenix

Teile doch einfach echt mit:

Delphi-Quellcode:

free_size / (3* 1024)

:shock: Warum soll er durch 3072 teilen? :gruebel:

ARGL.. jaaa.. ist ja gut... ich meinte 1024^3, mea culpa. Zu schnell getippt, zu wenig korrekturgelesen. Also mit Power potenzieren oder kurz selber ausrechnen: free_size / 1073741824.

[Phoenix]

Zitat:

Zitat von mlspider

Delphi-Quellcode:

FloatToStr(free_size / (3* 1024)) + #13 + 'total size=' +
FloatToStr(total_size / (3* 1024)))

Bringt zwar keinen Compilerfehler, dafür aber falsche Werte.

Wenn Du den rest jetzt noch liest weisst Du, dass ich mich da mit dem *3 vertan habe und es hoch drei sein müsste...

Aber das ist Grundlegende Mathe.. da könnte man auch selber draufkommen...

[mlspider]

Das haut hin. Nur finde ich 12 Nachkommastellen doch ein wenig viel. 2 würden auch reichen.

[Die Muhkuh]

Round
RoundTo
FloatToStrF

[Zacherl]

FloatToStrF ;)

Bisschen mehr Eigeninitiative ..

//Edit: Red box :evil:

[Angel4585]

Und jetzt noch ein Doppelpost das kost mindestens 2,5 Cent in Daniels Kaffeekasse :warn:

BTW:
ich würde
Format('%.2f GB',[freesize / Power(1024,3)]) nehmen

:zwinker:

[Phoenix]

Erm.. sorry Mario, aber vielleicht solltest Du die Handbücher vor dem Verheizen auch mal kurz anlesen... :thumb:

[ste_ett]

Zitat:

Zitat von TeronG

(und evtl. mit RoundTo noch n bissl "Pimpen")

[mlspider]

@Phoenix, bereits geschehen. Habe ab und an immer wieder Verständnisprobleme, was die formatiererei angeht. Habe es aber hinbekommen. Danke.

[Hawkeye219]

Hallo,

falls die Laufwerke mal etwas kleiner oder größer sind:

Delphi-Quellcode:

function FormatFileSize (aSize: Int64): string;

const 
  MB = Int64(1024 * 1024);
  GB = Int64(1024 * MB);
  TB = Int64(1024 * GB);
  PB = Int64(1024 * TB);

  cSize  : array [0..5] of Int64 = (1, 1024, MB, GB, TB, PB);
  cLabel : array [0..5] of string = ('B', 'KB', 'MB', 'GB', 'TB', 'PB');

var 
  lIndex : Integer;

begin
  lIndex := Ord(aSize >= cSize[1]) + Ord(aSize >= cSize[2])
            + Ord(aSize >= cSize[3]) + Ord(aSize >= cSize[4])
            + Ord(aSize >= cSize[5]);
  Result := Format('%g %s', [Int(100.0 * aSize / cSize[lIndex]) / 100, cLabel[lIndex]]);
end;

Gruß Hawkeye

[yörsch]

Nachtrag zum Runden: Immer so spät Runden wie möglich! das erhöht die Genauigkeit... :stupid:

[pilic]

Hi,

sorry für die Kleinlichkeit, aber polically correct wären doch Angaben in KiB, MiB. Also Kibibyte und co. Ich finde es zwar auch nicht toll, aber es muss doch neuerdings so angegeben werden, wenn durch 2^10 anstatt durch 1000, was die Vorsilbe kilo ja eigentlich bedeutet, geteilt wird.v :gruebel:

Cheerio

[TeronG]

Zitat:

Zitat von pilic

... aber es muss doch neuerdings so angegeben werden ...

MUSS!? auch in der DP!?
Das zeuch gibbet schon seit Jahren und irgendwie glaub ich nicht recht daran, daß sich das jemals durchsetzen wird ^^

[stahli]

OT: Wenn das Kilo nix wiegt, sind´s 1024 Stück. Das war doch schon immer so!? ;-))

[oki]

FormatFloat

Gruß oki

[xZise]

Zitat:

Zitat von TeronG

Zitat:

Zitat von pilic

... aber es muss doch neuerdings so angegeben werden ...

MUSS!? auch in der DP!?
Das zeuch gibbet schon seit Jahren und irgendwie glaub ich nicht recht daran, daß sich das jemals durchsetzen wird ^^

;) Es macht keiner, aber es wird empfohlen:

Wikipedia : Byte : Einheiten für große Mengen Bytes

Zu dieser abweichenden Verwendung kam es dadurch, daß aus technischen Gründen Halbleiterspeicher üblicherweise in Größen von Zweierpotenzen hergestellt werden, die Binärpräfixe jedoch erst sehr spät eingeführt wurden und daher die SI-Präfixe in etwas ungenauer Weise für Zweierpotenzvielfache von Byte verwendet wurden. Das für die SI-Präfixe zuständige Internationale Büro für Maß und Gewicht (BIPM) rät von dieser nicht standardkonformen Verwendung der SI-Präfixe ausdrücklich ab und empfiehlt für die Bezeichnung von Zweierpotenzen die Binärpräfixe gemäß IEC 60027-2 [2]. Trotzdem werden die SI-Präfixe besonders im nichtwissenschaftlichen Bereich häufig weiterhin in der Bedeutung der Binärpräfixe verwendet.

[2] - BIPM – SI-Broschüre, 8. Auflage, März 2006, Abschnitt 3.1: SI-Präfixe. Randnotiz. [1]