Abschneiden einer decimal-Wert in C++

Was ist der einfachste Weg abschneiden eine C++ float variable, der ein Wert von 0.6000002 auf einen Wert von 0.6000 und speichern Sie es zurück in die variable?

InformationsquelleAutor BeachRunnerFred | 2008-11-20

c++decimal truncate

Zunächst ist es wichtig zu wissen, dass floating-point-zahlen sind angenähert. Siehe den link von @Greg Hewgill, um zu verstehen, warum dieses problem ist nicht vollständig lösbar.

Aber hier sind ein paar Lösungen für das problem, die wird wahrscheinlich erfüllen Ihre Notwendigkeit:

Wohl die bessere Methode aber weniger effizient:

char sz[64];
double lf = 0.600000002;
sprintf(sz, "%.4lf\n", lf); //sz contains 0.6000

double lf2 = atof(sz);

//lf == 0.600000002;
//lf2 == 0.6000

printf("%.4lf", lf2); //print 0.6000

Der effizientere Weg, aber vermutlich weniger präzise:

double lf = 0.600000002;
int iSigned = lf > 0? 1: -1;
unsigned int uiTemp = (lf*pow(10, 4)) * iSigned; //Note I'm using unsigned int so that I can increase the precision of the truncate
lf = (((double)uiTemp)/pow(10,4) * iSigned);

InformationsquelleAutor Brian R. Bondy

12

Eine gute Referenz für warum dies geschieht, finden Sie in Was Jeder Computer Scientist Should Know About Floating-Point Arithmetic von David Goldberg.
- Vielen Dank für die Buchung der link Greg, ich dachte, dass die genau dokumentieren, Wann schrieb ich meine Antwort, aber konnte nicht für das Leben von mir erinnern, den Titel.
InformationsquelleAutor Greg Hewgill
6

Realistisch ist das nicht möglich. Es ist kein C++ Einschränkung, sondern gerade die Weise, die floating point arbeitet. Für viele Werte gibt es keine genauen zusagen, so können Sie nicht einfach abschneiden, um eine Anzahl von stellen.

Könnte man abschneiden beim drucken Verwendung von printf-format-strings.

Wenn Sie wirklich brauchen, um in der Lage zu speichern nur eine begrenzte Anzahl von Ziffern, ich schlage vor, Sie verwenden eine Feste-precision-Datentyp statt.

InformationsquelleAutor Kamil Kisiel
3

ich denke, die Frage, die hier gestellt werden sollte ist:
Warum müssen Sie es abgeschnitten?

Wenn Ihr einen Vergleich zwischen den Werten, sollten Sie vielleicht erwägen den epsilon-test. (mit einer extra-Toleranz-Wert, in deinem Fall, da es scheint zu sein, weit größer als die allgemein akzeptierte epsilon).

Wenn Sie nur wollen, drucken Sie es aus, wie 0.6000 , die Methoden verwenden, die andere vorgeschlagen haben.

InformationsquelleAutor Alex Lim
1
```
roundf(myfloat * powf(10, numDigits)) / powf(10, numDigits);
```
Zum Beispiel, in deinem Fall bist du mit dem abschneiden von drei Ziffern (numDigits). Sie würden verwenden:
```
roundf(0.6000002 * 1000) / 1000
//And thus:
roundf(600.0002) / 1000
600 / 1000
0.6
```
(Sie würde wahrscheinlich das Ergebnis speichern von powf irgendwo, da Sie es zweimal.)

Wegen, wie Sie schwimmt normalerweise auf Computern gespeichert werden, würde es wahrscheinlich zu Ungenauigkeiten. Das ist, was Sie erhalten, für die Verwendung von floats, obwohl.

InformationsquelleAutor strager
1

Verwenden:
```
floor(0.6000002*10000)/10000
```
InformationsquelleAutor JBOI
1

Für C++11 können Sie std::round definiert im header <cmath>:
```
auto trunc_value = std::round(value_to_trunc * 10000) / 10000;
```
InformationsquelleAutor chema989

Hier ist eine Funktion, mit der Beratung in anderen Antworten und ein Beispiel für die Verwendung:

#include <iostream>
#include <cmath>

static void Truncate(double& d, unsigned int numberOfDecimalsToKeep);

int main(int, char*[])
{

  double a = 1.23456789;
  unsigned int numDigits = 3;

  std::cout << a << std::endl;

  Truncate(a,3);

  std::cout << a << std::endl;

  return 0;
}

void Truncate(double& d, unsigned int numberOfDecimalsToKeep)
{
    d = roundf(d * powf(10, numberOfDecimalsToKeep)) / powf(10, numberOfDecimalsToKeep);
}

InformationsquelleAutor David Doria

0

Ähnlich zu anderen Antworten, ABER Sie dürfen nicht vergessen, dass die Runde, auf dem Boden und Rumpf unterschiedlich sind per definition. Siehe die definition und Ausgabe-Beispiel der folgende:

http://www.cplusplus.com/reference/cmath/trunc/

In diesem Fall müssen wir trucate mit einer Genauigkeit von 4 Dezimalstellen und loswerden von nicht-signifikanten Dezimalstellen:
```
trunc(valueToTrunc*10000)/10000
```
oder
```
value = (double)((int)(valueToTrunc*10000))/(double)10000
```
InformationsquelleAutor Rubarb

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.