string to Float, für lesen aus einer Datei

[bernhard_LA]

ich muss Zahlen aus einer Datei einlesen, die entweder mit deutschem (1,234) oder amerikanischem Decimalsparator (1.234) erstellt wurden.
Die Anwendung soll auf Windows Systemen mit Sprache Deutsch oder Englisch dann laufen und die eingelesenen Strings immer richtig interpretieren

Gibt es hier eine bessere Lösung als meine ?

Delphi-Quellcode:

  function ChangeLocalFloatStr (FloatStr : String ) : String;
var usedDecimalSeparator : Char ;
    NOTusedDecimalSeparator : Char ;
begin
   //   egal was der user eingestellt hat ......
   usedDecimalSeparator := TFormatsettings.Invariant.DecimalSeparator;

   if usedDecimalSeparator=',' then  NOTusedDecimalSeparator:='.'
          else  NOTusedDecimalSeparator :=',';


   if pos (usedDecimalSeparator , FloatStr) > 0   then
       begin
          result := FloatStr;
       end
       else
       begin
          result := stringreplace(FloatStr, NOTusedDecimalSeparator , usedDecimalSeparator,
                          [rfReplaceAll, rfIgnoreCase]);
       end;

end;

Aufruf :

Delphi-Quellcode:

a : real; 
astr : String ; 


 a := FloatToStr(   ChangeLocalFloatStr (astr)) ;

[Zacherl]

Rein von der Lösungsmöglichkeit her würde ich es auch so machen. Statt StringReplace würde ich allerdings direkt FloatStr[DelimPos] := '.' setzen, also den Parameter als var übergeben. So sparst du dir das Rumkopieren im Speicher. Mehrere Vorkommen des Dezimalseparators innerhalb eines einzelnen Wertes sind ja eh nicht zulässig, weshalb StringReplace mit rfReplaceAll auch Overkill sein sollte.

Delphi-Quellcode:

function ChangeLocalFloatStr(var FloatStr: String): String;
var
  I: Integer;
begin
  I := Pos(',', FloatStr);
  if (I > 0) then
  begin
    FloatStr[I] := TFormatSettings.Invariant.DecimalSeparator;
  end;
end;

Die ganzen zusätzlichen Variablen würde ich mir auch sparen. Achso, dann musst du den StrToFloat Aufruf natürlich abändern in StrToFloat(FloatStr, TFormatSettings.Invariant) .

Alternativ alles ganz kompakt (dann sparst du dir beim Aufrufen die zusätzliche Variable):

Delphi-Quellcode:

function LocalStrToFloat(FloatStr: String): Double;
var
  I: Integer;
begin
  I := Pos(',', FloatStr);
  if (I > 0) then
  begin
    FloatStr[I] := TFormatSettings.Invariant.DecimalSeparator;
  end;
  Result := StrToFloat(FloatStr, TFormatSettings.Invariant);
end;

[Neumann]

Es gibt dann aber noch folgende Schreibweise für Zahlen, die berücksichtigt werden müssten:

10,000,000.34 oder ev. auch 10.000.000,34

[markus5766h]

Zitat von Neumann:

Es gibt dann aber noch folgende Schreibweise für Zahlen, die berücksichtigt werden müssten:

10,000,000.34 oder ev. auch 10.000.000,34

. . . siehe Post #2 :
"Mehrere Vorkommen des Dezimalseparators innerhalb eines einzelnen Wertes sind ja eh nicht zulässig, ..."

bei "10.000.000,34" könnt' ich mir glatt überlegen, ob dies eine IP-Adresse sein soll

aber mal ernsthaft : ich hab' solche Schreibweisen mit mehreren Separatoren auch schon gesehen und dann gegrübelt, was das denn nun sein soll - man kann von einer Software nicht erwarten, dass sie die Absicht oder Meinung desjenigen errät, der sich bei der Schreibweise von Zahlenwerten nicht an gängige Normen hält.
Im obigen Beispiel fallen mir gleich 4 mögliche Lösungen ein, die ich dann abfragen bzw. auswerten müsste . . .

[KodeZwerg]

Zitat von markus5766h:

"Mehrere Vorkommen des Dezimalseparators innerhalb eines einzelnen Wertes sind ja eh nicht zulässig, ..."
Im obigen Beispiel fallen mir gleich 4 mögliche Lösungen ein, die ich dann abfragen bzw. auswerten müsste . . .

Ich bin der Meinung das bei dem Beispiel nur ein Dezimalseperator vorhanden ist.
Als Lösung für so eine Situation schwebt mir so etwas vor:
String in einer Schleife nach "." und "," suchen lassen, das zuletzt gefundene wird als Seperator genommen, im gleichen Atemzug werden die 100'er Markierungen entfernt.

[Delphi.Narium]

Und was passiert hierbei?

1.001
1,001
100,001
100.001

Was ist jetzt Eintausendeins und was Einskommanullnulleins?
Was ist Einhundertkommanullnulleins und was Einhunderttausendeins?

Für eine sichere Erkennung des Dezimalseparators benötigt man mindestens zwei Tausenderseperatoren und damit Werte über einer Million.

[KodeZwerg]

Ich verstehe was Du meinst, da wird es schnell chaotisch.
Na dann Fragen wir doch mal den TE ob 1000'er Markierungen überhaupt vorliegen.

So hier könnte man testen ob eine Konvertierung gelingt bevor man es konvertiert:

Code:

funtion TestFloatStr ( S : String ) : Boolean;
begin
  try
    StrToFloat(s); // normal aufrufen
    result := true; // scheint keine Exception auszulösen also ist Wert gut
  except
    result := false; // oh-oh, fehler!
  end;
end;

[Uwe Raabe]

Zitat von KodeZwerg:

So hier könnte man testen ob eine Konvertierung gelingt bevor man es konvertiert:

Oder man benutzt gleich TryStrToFloat oder Double.TryParse mit den erwarteten FormatSettings . Das hat den Nebeneffekt, daß es auch gleich konvertiert, wenn das denn möglich ist.

[KodeZwerg]

Das mit dem Double.TryParse war mir neu und klingt interessant, ich habe jetzt ein wenig darüber gelesen, per CultureInfo/InvariantCulture kann man das "." und "," Problem in den Griff bekommen. Aber wenn die Quelle gemixt ist, da hilft sowas auch nicht weiter, vermute ich, Danke für den Tipp!

[Uwe Raabe]

Zitat von KodeZwerg:

Aber wenn die Quelle gemixt ist, da hilft sowas auch nicht weiter, vermute ich

Das ist auch nicht allein aus den Daten zu ermitteln.

Zitat von Delphi.Narium:

1.001
1,001
100,001
100.001

Schönes Beispiel. Je nach Dezimal- und Tausndertrenner sind alle vier Zahlen in beiden Systemen gültig, haben halt nur unterschiedliche Bedeutung.