3. Warum 1.f?

Warum 1.f?

  • X

    Hi,

    Warum sehe ich in manchen Tutorials Sachen wie glClearDepth(1.f); anstatt glClearDepth(1);? Soweit ich weiß müsste dises ".f" in C++ doch überflüssig sein oder?

    Mfg x4rd3n

    0
  • A

    Diese Notation bedeutet, dass es sich bei dieser Konstante um den Typ float handelt. Das Weglassen von f würde eine implizite Konvertierung von int nach float bedeuten.

    0
  • F
     

    float i = 5; //==
float i = 5f;

    Das kannste auch mit long beispielweise machen (dann halt mit nem L).

    lg, freakC++

    0
  • X

    was das "f" am Ende bedeutet ist mir schon klar. Aber warum wird es benutzt? "flaot i = 5;" geht doch auch. Oder kostet diese implizierte Koverntierung von int nach float prozessor zeit?

    0
  • N
     

    void foo(int x);
void foo(float x);

foo(42); // verdammt, falsche Funktion

    template <typename T>
void foo(T t);

foo(42); // verdammt, falsche Template-Instanziierung

    int foo();

float a = foo() / 42; // verdammt, falsches Resultat
    0
  • X

    Nexus schrieb:

    void foo(int x);
void foo(float x);

foo(42); // verdammt, falsche Funktion

    template <typename T>
void foo(T t);

foo(42); // verdammt, falsche Template-Instanziierung

    int foo();

float a = foo() / 42; // verdammt, falsches Resultat

    all dies ist mir bewusst. Aber spricht IRGENDetwas gegend folgendes:

    void foo(float bar); // nein diese funktion ist nicht irgendwie überladen es existiert nur diese eine
foo(1);

    Vll ist dir OpenGL geläufig. Da gibt es z.b. den befehl glClearDepth der ist glaube ich folgendermaßen deklariert:

    void glClearDepth(float depth); // in der realität heißt der typ GLclampd, dieser typ existiert aber nur um OGL sprachenportabel machen zu können

    aber trozdem sehe ich of glClearDepth(1.0f), dafür suche ich den Grund.

    0
  • D

    Warum eine Konvertierung, wenn keine nötig ist? - Es sind andere Typen und dann kann man ja gleich den richtigen angeben..

    Es könnte ja sein, dass es mal eine Funktion geben soll, die so aussieht:

    void glClearDepth(int depth);

    Und dann funktioniert dein Beispiel nicht, wie gewünscht, weil du einen falschen/anderen Typen angegeben hast.

    0
  • X

    wie gesagt meine Fragen beziehen sich nur auf _nicht_ überladene Funktionen. Und ich finde die "*f" nicht so intuitiv wie die ohne. Also gibt es von der Performance seite Gründe dagegen?

    0
  • D

    (Soll ich jetzt sagen, dass dein Programm dann lediglich 1% der Performance hat, damit du anständig programmierst?)

    Nein. Im Ernst. Es macht nix aus, aber das ist kein Grund da was falsches zu machen..

    Es ging ja nicht um bestehende überladene Funktionen, sondern um die Erweiterbarkeit.

    0
  • ?

    Sind in C überhaupt Überladungen möglich?

    0
  • X

    Für mich wäre schon 1 Assembler-anweisung mehr Grund zum *f stil zu wechseln. Ich finde allerdings das

    int foo = 1;
bar(foo);

    lesbarer ist als

    int foo = 1;
bar(float(foo));

    um die Beispiele auf Variablen auszudehnen (da ist dann schon mehr schreibarbeit als nur ein extra Zeichen vonnöten.

    0
  • A

    Komisch, wo manche Leute versuchen wollen, Performance raus zu holen. 🙄
    80% der Laufzeit werden von 20% des Codes benutzt.

    Edit: Wieso sollte man explizit konvertieren? Das ist jetzt wirklich nicht notwendig.

    0
  • X

    @hmmmmmm: nein
    @Ad aCTa: ich wills nur "richtig" machen

    0
  • U

    x4rd3n schrieb:

    @hmmmmmm: nein
    @Ad aCTa: ich wills nur "richtig" machen

    man sollte dem compiler eigtl keine einzige konvertierungen überlassen - nicht weil er dumm wäre, sondern weil es eine potentielle fehlerquelle ist...
    ne gleitkommazahl ist nun mal nicht so genau wie ne ganzzahl und ne ganzzahl kann nun mal auch nur ganze zahlen darstellen. das ist auch der grund, warum dich der compiler(zumindest der msvc) bei fast jeder konvertierung warnt - weil es ab und an ja wirklich ungewollt ist und böse(kleinerer wertebereich -> zahl wird abgeschnitten) folgen haben kann...
    und ob ich nun foo(1) oder foo(1.f) schreibe sollte vom schreibaufwand ja völlig egal sein - es sei denn, dich bremst beim programmieren wirklich deine tippgeschwindigkeit...

    nötig sollte es weder in C noch in C++ sein, aber nicht nötig heißt nicht zwangsläufig immer, dass es gut ist, es wegzulassen...

    bb

    0
  • D

    Richtig ist, wenn du die erwarteten Typen benutzt. Das ist bei einem float Literal halt das ".f".

    0
  • ?
     

    WINGDIAPI void APIENTRY glClearDepth (GLclampd depth)
typedef double GLclampd;
    0
  • X

    Das ist hingegen auch intressant 🙂

    0
  • A

    Das ändert für dich im Endeffekt nur eine andere Tatsache: jetzt solltest du

    glClearDepth(3.0)

    schreiben, also auf jeden Fall einen Punkt.

    0
  • B

    Es gibt keine Performance-Gründe für oder gegen "1.f". Es gibt nur lauter mehr (potentielle Überladung) oder weniger (Einsparen von impliziten Konvertierungen) nachvollziehbare Pseudogründe, die du schön kompakt hier im Thread nachlesen kannst. Wenn du sie glaubst, machst du es auch so, wenn nicht, dann nicht.

    0
  • ?

    x4rd3n schrieb:

    Oder kostet diese implizierte Koverntierung von int nach float prozessor zeit?

    Höchstens beim Kompilieren.

    0
Anmelden zum Antworten