3. Hexadezimal nach float konvertieren (IEEE format)

Hexadezimal nach float konvertieren (IEEE format)

  • H

    Ich habe zum Thema IEEE in der suche 4 Themen gefunden, nur leider gehen sie an dem vorbei was ich brauche.

    Ich habe eine Hex-Zahl 3F0E5604
    Die ist dezimal (laut anderer Software) 0.5559999942779541

    Hier meine Quelle:
    http://babbage.cs.qc.edu/courses/cs341/IEEE-754hex32.html

    Ich weiß nur nicht wie ich auf den Wert komme.
    Ich brauche eine c/c++ Funktion mit der ich das umrechnen kann.

    Kann mir wer helfen?

    0

  • Schau dir doch 'mal den HTML (bzw. JavaScript) Code der Seite an, deren Link du gepostet hast 😉

    Greetz, Swordfish

    0
  • V

    Hier ein kleines Beispiel wie du es ohne großen Aufwand machen kannst.
    Achtung der reinterpret_cast ist ein sehr gefährliches aber
    auch ein sehr nützliches Werkszeug.

    int hexval = 0x3F0E5604;
float* val = reinterpret_cast<float*>(&hexval);
std::cout << std::setprecision(10) << *val << std::endl;

    Ich hoffe das hilft dir ein wenig.

    0

  • @Viper190: wohl eher:

    #include <iostream>

using namespace std;

int main( )
{
    unsigned int hexval = 0x3F0E5604;
    float *val = reinterpret_cast< float* >( &hexval );
    cout.precision( 10 );  // <-- !!
    cout << *val << endl;
}

    Ach ja, warum ist reinterpret_cast< > gefährlich?

    Greetz, Swordfish

    0
  • H

    Oha...
    Wenn ich ehrlich bin würde ich mir den Quellcode nur kopieren und hoffen das es stimmt, da ich ihn leider nicht ganz verstehe.

    Zuden habe ich derzeit den HexWert nur in einer CString Variablen

    CString sHexWert.

    Könntet ihr mir nochmal ein Beispiel machen wie ich von dem CString auf meine floatzahl komme?

    Ich danke eu vorab schonmal recht herzlich.
    Auch für die schon geleisteten Posts 😉

    0
  • J

    Swordfish schrieb:

    Ach ja, warum ist reinterpret_cast< > gefährlich?

    Weil er nicht plattformunabhängig ist und vorallem nicht auf die größe achtet. Beispiel:

    #include <iostream>

int main()
{
    int a = 0x3F0E5604;
    std::cout << *reinterpret_cast<double*>(&a) << std::endl;
}

    Double ist meistens 8 Byte groß und int nur 4. Also haben wir hier einen Zugriff auf 4 Byte die hinter a liegen, die evtl. uninitialisiert sind -> undefiniertes Verhalten. (oder auch Zugriffsverletzung)

    Erkennst du auch daran, dass das Programm immer ne andere Ausgabe hat (zu mindestens bei mir).

    mfg.

    0
  • V

    Ich kann deinem Post joomoo nur zustimmen.
    Vielen Dank das du das für mich beantwortet hast.

    Deswegen habe ich in meinem Beispiel oben einen

    float

    benutzt.
    Dann ist die Ausgabe konstant da kein nicht initialisierter Speicher
    vorhanden ist.

    Gruß
    Viper190

    0
  • V

    Für dein ganzes Problem habe ich dir folgenden Code geschrieben.
    ich arbeite hier allerdings mit einem std::string (std::basic_string).
    Du musst halt deinen CString noch zu einem std::string bringen.
    (Sorry habe hier keine CString zu verfügung)

    #include <iostream>
#include <string>
#include <sstream>
#include <iomanip>

template <class T>
bool from_string(T& t, 
                 const std::string& s, 
                 std::ios_base& (*f)(std::ios_base&))
{
  std::istringstream iss(s);
  return !(iss >> f >> t).fail();
}

int main(int argc, char* argv[])
{

	int intValue;
	from_string<int>(intValue, std::string("3F0E5604"), std::hex);
	float *val = reinterpret_cast< float* >( &intValue );
	std::cout << std::setprecision(10) << *val << std::endl;
	return 0;
}

    Gruß
    Viper 190

    0

  • @Joomoo & Viper190: Ist mir schon klar. Ich würde einen reinterpret_cast< > jedoch desswegen nicht mit gefährlich attributieren. Man sollte bloß wissen, was man macht.

    Greetz, Swordfish

    0
  • V

    Vielleicht war gefährlich von mir ein wenig falsch gewählt.
    Sorry wollte deswegen jetzt keine Diskussion anfangen.

    Ja man muss halt wissen was man mach 😉

    cheers

    0
  • H

    Vielen dank! Ich teste es gleich 😉

    0
  • H

    Viper190 schrieb:

    Für dein ganzes Problem habe ich dir folgenden Code geschrieben.
    ich arbeite hier allerdings mit einem std::string (std::basic_string).
    Du musst halt deinen CString noch zu einem std::string bringen.
    (Sorry habe hier keine CString zu verfügung)

    #include <iostream>
#include <string>
#include <sstream>
#include <iomanip>

template <class T>
bool from_string(T& t, 
                 const std::string& s, 
                 std::ios_base& (*f)(std::ios_base&))
{
  std::istringstream iss(s);
  return !(iss >> f >> t).fail();
}

int main(int argc, char* argv[])
{
	
	int intValue;
	from_string<int>(intValue, std::string("3F0E5604"), std::hex);
	float *val = reinterpret_cast< float* >( &intValue );
	std::cout << std::setprecision(10) << *val << std::endl;
	return 0;
}

    Gruß
    Viper 190

    Joa super!!
    So geht es... ABER ^^

    Wie zum Geier wandle ich mein CString zu einem std::string.
    Bekomme ich nicht gebacken 🙄

    -------------- EDIT --------------
    Sorry habe versucht ne falsch Variable zu übergeben ^^

    so geht es

    /* Hex in float wndeln */
	CString sNutzDaten = "3F0E5604";

    from_string<int>(intValue, LPCTSTR(sNutzDaten), std::hex);
    float *val = reinterpret_cast< float* >( &intValue );
    std::cout << std::setprecision(10) << *val << std::endl;

	/* Ausgabe in einer EditBox */
	sNutzDaten.Format("%.3f",*val);
	GetDlgItem(IDC_LAST_RECIVED_STRING)->SetWindowText(sNutzDaten);
    0

  • Bei mir funktioniert

    #include <string>
#include <iostream>

#include <atlstr.h>

using namespace std;

int main( )
{
    CString cs = "Hello";
    string str;

    str = cs;

    cout << str << endl;
}

    tadellos. Somit müsste der Aufruf von

    headfinger schrieb:

    from_string< int >( intValue, LPCTSTR( sNutzDaten ), std::hex );

    auch ohne dem Cast von sNutzDaten zu LPCTSTR funktionieren.

    Greetz, Swordfish

    0

  • Irgendwie ist die Frage doch etwas sinnlos. Wenn man 'nen float im Rechner abspeichert, dann ist er doch im IEEE Format. Was gibts da noch zu konvertieren? Die sauberste Methode um sowas dann als anderen Typ zu lesen oder gar zu schreiben ist IMHO eine union. Da sorgt der Compiler dafür, das man keinen Speicher benutzt der einem nicht gehört. f'`8k

    Gruß, TGGC (\-/ returns)

    0

  • @TGGGC:

    meinst du so:

    #include <iostream>

using namespace std;

union IEEE_float_converter_t {

    float f;
    unsigned int i;
};

int main( )
{
    IEEE_float_converter_t ieeefc;
    ieeefc.i = 0x3F0E5604;

    cout << hex << ieeefc.i << " entspricht ";

    cout.precision( 10 );
    cout << ieeefc.f << endl;
}

    oder?

    Greetz, Swordfish

    0
  • ?

    und wie wärs damit? man müsste sich natürlich noch ein bisschen gedanken um die byte-reihenfolge machen - muss man aber mit int auch.

    union IEEE_float_converter_t 
{	
    float f;
    unsigned char c[sizeof(float)];
};
    0

  • Wie genau, das hängt davon ab, was man erreichen will. So genau definiert das die Frage überhaupt nicht. f'`8k

    Gruß, TGGC (\-/ returns)

    0

  • Ach TGGC, sei nicht immer so kleinlich. Wenn du es nur ungefähr so gemeint hast, wie hast du es dann exakt gemeint?

    Greetz, Swordfish

    0
Anmelden zum Antworten