ich habe eine Funktion geschrieben, die eine Gleitkommazahl rundet. Hier ist der Code:;

int round (float Zahl)                                                           // Bsp. mit Pi (ca. 3.1415) //7.6
{
  vector <int>Test;
  Test.push_back (static_cast <int>(Zahl));                         //Test[0] ist 3 und Test[1] ist 4 //[0] = 7, [1] = 8
  Test.push_back (Test[0] + 1);

  if (Zahl - Test[0] < Test[1] - Zahl)                                       //--> 3.1415 - 3 = 0.1415; 4 - 3.1415 = 0.9695
  {  
    return Test[0];
  }
  else //if (Zahl - Test[0] >= Test[1] - Zahl)
  {
    return Test[1];
  }
}

Am Beispiel von Pi funktioniert das alles ja noch, aber wenn ich dann beispielsweise
das Ganze mit 7.6 mache liefert die Funktion mir 7 zurück, obwohl 8 richtig wäre.
Hat irgendjemand eine Idee, was falsch ist?

Was spricht gegen

int Round(float decimal)
{
    return static_cast<int>(decimal + 0.5f);
}

Kommt halt drauf an, wie du negative Zahlen behandeln willst.

Da fühle ich mich sehr unwohl, wenn ein vector mitspielt.

return static_cast<int>(floor(zahl+0.5));

Warum floor() ?

Auf die Idee bin ich garnicht gekommen. Warum ist Vector hier eigentlich nicht angebracht?

Auf die Idee bin ich garnicht gekommen. Warum ist Vector hier eigentlich nicht angebracht?

Weil std::vector schon nur einige Byte Speicheroverhead hat, ohne die eigentlichen Elemente. Dazu kommt die dynamische Speicheranforderung und Vergrösserung mit entsprechendem Umkopieren. Da der Standard-Heap-Allokator meistens auch übermässig viel Overhead hat und nicht für kleine Allokationen optimiert ist, hat man dort wieder Speicher verschwendet. Von der nötigen Zeit eines new und delete ganz zu schweigen. Alles total unnötig.

Merke dir einfach, dass Containerklassen nicht ganz leichtgewichtig sind und dazu eingesetzt werden sollten, um mehrere Elemente zu speichern. Ihre Stärken zahlen sich besonders bei vielen Elementen aus. Für so kleine Algorithmen nimmst du lieber einzelne automatische Variablen, oder wenns geht (und hier geht es) ein Einzeiler mit temporären Ausdrücken.

volkard schrieb:

return static_cast<int>(floor(zahl+0.5));

Warum floor() ?

War zu faul zu überlegen, wohin der static_cast rundet.
Wohin rundet er? Und was passiert bei Minuszahlen?

Wohin rundet er?

Bei positiven Zahlen werden doch einfach die Nachkommastellen abgeschnitten, oder?

volkard schrieb:

Und was passiert bei Minuszahlen?

Die hast du ja mit assert() ausgeschlossen.

Naja, je nachdem will man Minuszahlen vielleicht anders behandeln. Von daher auch "Kommt halt drauf an, wie du negative Zahlen behandeln willst". Ich bin mir aber nicht sicher, ob der Standard bei static_cast garantiert, dass negative Zahlen in eine bestimmte Richtung gerundet werden, vielleicht ist dazu wirklich floor() nötig.

#include <iostream>
using namespace std;

int round (float Zahl)
{
  return static_cast <int>(Zahl + 0.5);
}

int main ()
{
  int pi=3.9;
  cout <<round (pi);
}

int pi=3.9;//löl

C++H schrieb:

int pi=3.9;//löl

Ja, ich weiß, dass Pi nicht 3.9 ist, aber ansonsten verstehe ich dein löl nicht.

Ja, ich weiß, dass Pi nicht 3.9 ist, aber ansonsten verstehe ich dein löl nicht.

Schau doch mal den Datentypen an.

Ein guter Compiler hätte dir eine Warnung dafür ausgespuckt, schadet im allgemeinen nicht auch alle Warnungen aus deinem Projekt zu beheben.

warning C4244: 'initializing' : conversion from 'double' to 'int', possible loss of data

int pi=3.9;

Ein guter Compiler hätte dir eine Warnung dafür ausgespuckt, schadet im allgemeinen nicht auch alle Warnungen aus deinem Projekt zu entfernen.

"Error: Wrong value for 'pi'"

int round(float Zahl)
{
  return static_cast<int>((Zahl < 0) ? Zahl - 0.5 : Zahl + 0.5);
}

Oder liege ich da falsch?