2 int zu 1 float ?



  • Hi,

    wie ist es möglich 2 int zusammenzufassen und als float zu speichern?

    z.b:

    AUS:
    int a = 513
    int b = 261
    
    SOLL:
    float c = 513.261
    

    danke.



  • durch 1000 teilen und addieren.



  • Bei beliebigem Wert von b müßte man den Log10 davon berechnen und dann durch 10^(x+1) teilen.

    PS: Falsches Subforum...



  • @pokemon99
    Hallo!

    geht mit union:

    #include <iostream>

    using namespace std;

    union einheit
    {
    float messwert;
    unsigned char mwertbytes[4];
    unsigned short mwertshort[2];
    };

    void zeigeWerte(union einheit ehe)
    {
    int i;

    //Werte von unsigned char zeigen
    cout << "floatwert: " << ehe.messwert << endl << endl <<"Nun als unsigned char: " << endl;

    for (i = 0; i < 4; i++)
    cout << "mwertbytes" << i << "] = " << (int)ehe.mwertbytes[i] << endl;

    //Werte von unsigned char zeigen
    cout << endl << "Nun als unsigned short: " << endl;
    for (i = 0; i < 2; i++)
    cout << "mwertshort" << i << "] = " << (int)ehe.mwertshort[i] << endl;
    cout << "---------------------------------------------------------" << endl;
    }

    int main()
    {
    union einheit flint;

    cout << "Test" << endl;
    cout << "length of float: " << sizeof(float) << endl;
    cout << "length of short: " << sizeof(short) << endl << endl;

    flint.messwert = 123.4567;

    //Werte von unsigned char zeigen
    zeigeWerte(flint);

    flint.messwert = 0;

    cout << endl <<"Jetzt alle Variablen geloescht:" << endl;

    //Werte von unsigned char zeigen
    zeigeWerte(flint);

    flint.mwertshort[0] = 59861;
    flint.mwertshort[1] = 17142;

    cout << endl << "Jetzt Zuweisung von Werten an short-Variable:" << endl;

    //Werte von unsigned char zeigen
    zeigeWerte(flint);

    return EXIT_SUCCESS;
    }


  • Global Moderator |  Mod

    Unformatierte Antwort auf 6 Monate alte Frage, mit Code voller undefiniertem Verhalten, der die Frage nicht beantwortet, in der falschen Sprache 😡



  • Sorry, stimmt, hatte nebenbei noch geproggt



  • @rustyoldguy Und das erklärt diesen Haufen unerklärlichen Mists jetzt wie?



  • Mehr als entschuldigen kann ich nicht!

    Aber wenn wir schon mal beim kritisieren sind:

    1. Die Funktionen um code hier als solchen zu markieren sind nicht eindeutig in der Benutzeroberfläche dieses Forums als solches erkennbar, da etwas zu unauffällig.

    Weiter einfach durch 1000 teilen ist zu einfach, das geht nur bei dreistelligen Variablen.
    Th69 denkt da schon weiter. Braucht aber zumindest in c und c++ <math.h>

    Also zuerst die (Länge) des Nachkomma-Anteils feststellen.
    Geht übrigens in c und c++ auch mit while:

     float two_int_to_float(int vorkomma, int nachkomma)
     {
      int i, p = 0;
      float c = 0;
    
      i = 10E8;
      while(i > 0)
       {
        p = nachkomma / i;
        if (p > 0)
         break;
        //cout << nachkomma << "/" << i << " = " << p << endl;
        i /= 10;
       }
    
       c = (float)vorkomma + ((float)nachkomma / (float)(i * 10));
    
     return c;
    }
    

    Denn bei der "einfachen" Methode brauchst du keine extra math-Bibliothek einzubinden.
    Es sei denn der Datentyp int hat eine andere Länge als 4 Byte. Also ich kenne keinen, der noch 16-Bit Prozessoren verwendet, denn da wäre die Länge des Datentyps "int" 2 Byte. Der letzte war der 8086. bereits der 80386 hatte 32 Bit.

    Kleiner Ausflug in die Geschichte:
    Der Unterschied zwischen 80386 und 80486 war der, das beim 486er der mathematische Koprozessor mit integriert wurde.
    Übrigens Der Typ 80186 soll mal von Bill Gates als "hirntot" bezeichnet worden sein.

    Also gehe ich mal davon aus, das außer privaten Sammlern und Museen keiner mehr damit arbeitet oder?

    Was die "falsche" Sprache angeht:

    Man kann auch bei "anderen" na sagen wir mal, sich die Vorgehensweise anschauen. Das Wort "klauen"( Diebstahl geistigen Eigentums???) möchte ich aber vermeiden. Ist ungefähr so, wenn ich anderen Köchen zuschaue. Man muss ja die Rezepte nicht gleich total genau kopieren, man kann sich aber Anregungen für eigene Rezepte holen oder?



  • @rustyoldguy sagte in 2 int zu 1 float ?:

    Also gehe ich mal davon aus, das außer privaten Sammlern und Museen keiner mehr damit arbeitet oder?

    Und es gibt nur x86 und keine Embedded Entwickler?

    Was hat das mit den Köchen und Rezepten mit falscher Programmiersprache und klauen zu tun?



  • Hallo!
    Natürlich gibt es Embedded Entwickler, sind aber weniger im Licht der Öffentlichkeit zu finden.

    Beispiel zur Metapher mit den Köchen und Rezepten:
    Es gibt eine Menge Programmcode, was zuerst in Cobol oder Fortran entwickelt wurde. Später wurde viel auf c und c++ übertragen und dort weiter entwickelt. Übrigens hatte Motorola mit dem 68000er Chip zuerst einen Mikroprozessor mit 32 Bit. Warum sich den Kopf darüber zu zerbrechen, das gerade IBM mit der x86er-Serie das Rennen gemacht hatte und MSDOS statt OS2Warp3? Ist eben so.
    Vielleicht ändert sich was in den Köpfen der Leute was die Microsoft-Gläubigkeit anbetrifft, seit Meltown und Spectre, im Punkto Verfügbarkeit der Updates für die MS-Operationsysteme. Wie man die Veröffentlichungen bei Wikileaks(z.B. CIA-Projekt Angelfire, Athena, AfterMidnight, Pandemic, Grashopper Framework )bewerten kann, im Bezug auf die Hardware-Sicherheitslücken und MS, das sollte jeder für sich selber beantworten.
    Das ist hat der Nachteil vom "Kopieren", eben wie in der Schule: Wer vom Nachbarn abguckt, kopiert auch dessen Fehler.



  • @rustyoldguy sagte in 2 int zu 1 float ?:

    Denn bei der "einfachen" Methode brauchst du keine extra math-Bibliothek einzubinden.

    Doof ist bloß: integers sind exakt und wenn du 2 ints durch Umrechnen in ein float quetschen willst, könnte es sein dass dabei Genauigkeit verloren geht.

    Was immer klappen sollte ist, wenn man ein double nimmt (8 Bytes) und das in ein Array aus 2 ints umcastet (2 * 4 Bytes). Der double-Wert ist damit natürlich völlig kryptisch, aber die beiden ints sollte man immer verlustfrei wieder zurückbekommen.