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?

Greetz, Swordfish

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

Ich hoffe das hilft dir ein wenig.

#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

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

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.

Deswegen habe ich in meinem Beispiel oben einen

float

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

Gruß
Viper190

#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

Greetz, Swordfish

Ja man muss halt wissen was man mach

cheers

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);

#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

Gruß, TGGC (\-/ returns)

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

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

Gruß, TGGC (\-/ returns)

Greetz, Swordfish