Probleme mit reinterpret_cast<double*>

floriank

proggingmania schrieb:

int main()
{
	double k = 0.0;
	unsigned int komp = 3258761612;

 	memcpy( &k, &komp, sizeof(unsigned int) );
	cout << k << endl;

	komp = 123176233;
	k = 0.0;
	memcpy( &k, &komp, sizeof(unsigned int) );
	cout << k << endl;

	komp = 1538900071;
	k = 0.0;
	memcpy( &k, &komp, sizeof(unsigned int) );
	cout << k << endl;

	return 0;
}

Danke dafür. Nur noch eine Frage. Wenn ich nun den Hinweg anschaue, muss ich anscheinend mein double in 2 unsigned int speichern, richtig?
Wie kann ich diese beiden dann wieder zusammenführen?

Also konkret würde ich jetzt so vorgehen:

double k = 1.2345;  
unsigned int komp*;

memcpy( &komp, &k, sizeof(double) );

So daß ich den double-Wert in komp[0] und komp[1] gespeichert habe.
oder wenn das nicht klappt:

double k = 1.2345;  
unsigned int komp*;
komp = reinterpret_cast<unsigned int*>(&k);

Nur wie bekomme ich den Rückweg hin? Ich müßte ja jetzt komp[0] und komp[1] zurückführen nach k.

Florian

CStoll

Wenn du die beiden int-Werte die ganze Zeit am Stück hältst, sollte der Rückweg eigentlich genauso klappen wie der Hinweg:

double dval;
unsigned int ival[sizeof(double)/sizeof(int)];

dval=170.0;
memcpy(ival,&dval,sizeof(double));
...
memcpy(&dval,ival,sizeof(double));
cout<<dval;

floriank

CStoll schrieb:

Wenn du die beiden int-Werte die ganze Zeit am Stück hältst, sollte der Rückweg eigentlich genauso klappen wie der Hinweg:
double dval;
unsigned int ival[sizeof(double)/sizeof(int)];

dval=170.0;
memcpy(ival,&dval,sizeof(double));
...
memcpy(&dval,ival,sizeof(double));
cout<<dval;

Danke. Ich werde es mal versuchen einzubauen.

Florian

thordk

floriank schrieb:

double k = 1.2345;  
unsigned int komp*;

memcpy( &komp, &k, sizeof(double) );

pass auf mit sowas. du kopierst den inhalt von k hier in nicht allozierten speicher. vergleich das mit cstolls beispiel von eben.

LordJaxom

thordk schrieb:

pass auf mit sowas. du kopierst den inhalt von k hier in nicht allozierten speicher. vergleich das mit cstolls beispiel von eben.

Viel schlimmer, er multipliziert eine Variablendefinition mit dem Ende der Zeile

*scnr*

thordk

naja, und eigentlich versucht er auch den inhalt von k dahin zu schreiben, wo die adresse von komp steht (wenn man mal annimmt, dass die zeile richtig wär). aber das sind spitzfindigkeiten

floriank

thordk schrieb:

floriank schrieb:
double k = 1.2345;  
unsigned int komp*;

memcpy( &komp, &k, sizeof(double) );
pass auf mit sowas. du kopierst den inhalt von k hier in nicht allozierten speicher. vergleich das mit cstolls beispiel von eben.

den Speicher habe ich schon alloziert:

komp = (unsigned int*) calloc(sizeof (unsigned int), 2);

thordk

yikes, warum schreibst nich einfach unsigned komp[2]; ?

floriank

Hallo,

das richtige bekomme ich immer noch nicht zurück. Ich mache folgendes:

double data_double;
unsigned int* original;
original = (unsigned int*) calloc(sizeof (unsigned int), 2);
original = konvertierung_double (data_double);

unsigned int* konvertierung_double(double original)
{
    unsigned int* o;
    o = (unsigned int*) calloc(sizeof (unsigned int), 2);

    // Fall original ist positiv (inkl. +0)

    if (original >= 0 )
    {
	original *= (-1) ;
        // float wird als unsigned int interpretiert
	memcpy(o,&original,sizeof(double));
    }

    // Fall original ist negativ (inkl. -0)

    else
    {
        // Konvertierung in ein unsigned int
	memcpy(o,&original,sizeof(double));
        // alle Bits werden einzeln negiert
        o[0]=~o[0];
    }
    // Rückgabe des Wertes nach der Konvertierung
    return(o);
}
double unkomp_double;
unkomp_double= konvertierunginverse_double(original);

double konvertierunginverse_double(unsigned int* komp)
{

	double* k;
	k = (double*) calloc(sizeof (unsigned int), 1);

	// Fall original ist positiv (inkl. +0)

	unsigned int positiv = potenzieren(2,31);
	if (komp[0] >= positiv )
	{
		// float wird als unsigned int interpretiert
		komp[0] = komp[0] - positiv;
		memcpy(k,komp,sizeof(double));
	}

	// Fall original ist negativ (inkl. -0)

	else
	{
		komp[0] = ~komp[0];
		// Konvertierung in ein unsigned int
		memcpy(k,komp,sizeof(double));

	}
	// Rückgabe des Wertes nach der Konvertierung
	return(k[0]);
}

Normalerweise sollte nun unkomp_double=data_double

Ist es aber nicht. Mache ich noch etwas falsch?

CStoll

Erstmal hast du da ein Memory-Leck in der Funktion (bzw. der vor dem Funktionseintritt angeforderte Speicher verschwindet im Nirvana).

Und zweitens: Bist du sicher, daß die Bit-Anpassungen in den Funktionen auch zueinander passen? (vereinfache mal den Test, indem du die Fallunterscheidungen 'if(original>=0)...' bzw. 'if(komp[0]>=positiv)' weglässt)

floriank

CStoll schrieb:

Und zweitens: Bist du sicher, daß die Bit-Anpassungen in den Funktionen auch zueinander passen? (vereinfache mal den Test, indem du die Fallunterscheidungen 'if(original>=0)...' bzw. 'if(komp[0]>=positiv)' weglässt)

ja da bin ich mir eigentlich sicher. Zumindest stimmen diese, wenn es sich um floats handelt und somit der zweite Teil (also komp[1] usw. wegfällt).

Warum verschwindet der Speicherplatz? Wird der in der Funktion nicht mit übernommen, wenn doch der Zeiger mit übergeben wird?

Vielleicht verwirren die Bezeichnungen etwas. Ich habe das aus einem großen Programm herauskopiert. Ich bin mir eben nur sicher, daß es dazwischen alles funktioniert.

CStoll

floriank schrieb:

ja da bin ich mir eigentlich sicher. Zumindest stimmen diese, wenn es sich um floats handelt und somit der zweite Teil (also komp[1] usw. wegfällt).

Wenn der Zeiger übergeben wird, ja. Aber du übergibst ja nicht den Zeiger, der im Hauptprogramm mit Speicher versorgt wurde, sondern legst in der Funktion neuen Speicher an, der zurückgegeben wird.

Edit: Und daß die Umwandlungen mit floats klappen, beweist noch lange nichts über double's

floriank

Müßtes denn dann eigentlich nicht klappen, wenn ich aus den Zeigern arrays[2] mache?

Nur das funktioniert auch nicht.

Also anstatt:

unsigned int* original;
original = (unsigned int*) calloc(sizeof (unsigned int), 2);

unsigned int original[2];

usw.

proggingmania

floriank schrieb:

Normalerweise sollte nun unkomp_double=data_double
Ist es aber nicht. Mache ich noch etwas falsch?

Ja.

k = (double*) calloc(sizeof (unsigned int), 1);

Etwas zu wenig für double

komp[0] = ~komp[0];

Ich nehme an, das du damit gleichzeitig das MSB invertieren möchtest( wegen der Abfrage in Zeile 48 ), das liegt aber an Position komp[1]

if (komp[0] >= positiv );

siehe 2)
Also, setze Index 1 statt 0

Konrad Rudolph

CStoll schrieb:

(um auf Byte-Ebene hantieren zu können, sind die passenden C-Funktionen doch ideal)

'std::uninitialized_copy'.

*scnr*

thordk

ich mag memcpy. bilde mir ein, dass es schneller ist als alles andere

Konrad Rudolph schrieb:

CStoll schrieb:

(um auf Byte-Ebene hantieren zu können, sind die passenden C-Funktionen doch ideal)

'std::uninitialized_copy'.
*scnr*

Das war wohl jetzt ein "insider"
Als ob man in C nicht variablen initialisieren könnte
Klar, nehmen wir copy, brauchen wir nur noch eine Klasse für int und eine für double zu schreiben

Swordfish

************* schrieb:

Klar, nehmen wir copy, brauchen wir nur noch eine Klasse für int und eine für double zu schreiben

aja...

Muss man das jetzt verstehen?

#include <algorithm>
#include <iostream>

using namespace std;

int main( ) {

	int number = 0xff;
	int target = 14;

	cout << "number: " << number << "\ntarget: " << target << endl;

	std::copy< int*, int* >( &number, &( &number )[ 1 ], &target );

	cout << "\nnumber: " << number << "\ntarget: " << target << endl;
}

greetz, Swordfish

Konrad Rudolph

thordk schrieb:

ich mag memcpy. bilde mir ein, dass es schneller ist als alles andere

Es ist aber – zumindest in der Theorie – umgekehrt. 'std::copy' kann nämlich durch tag resolution und andere Techniken (partielle Template-Spezialisierung) für unterschiedliche Typen entsprechende Optimierungen durchführen (Boost hat dazu nen Beispiel für Boost.TypeTraits), sodass für jeden Typ die optimale Routine gewählt wird (z.B. 'memcpy', falls das am effizientesten sein sollte. 'memcpy' kann das nicht. Natürlich kann das dadurch ausgeglichen werden, dass der Compiler "schummelt" indem er Analysen durchführt aber, um Stroustrup frei zu zitieren, es ist immer besser, wenn man etwas über Bibliotheken lösen kann, als es über die Sprache (sprich, den Compiler) zu lösen.

proggingmania

Was ist mit deinem Konverter, läuft das jetzt ?

Probleme mit reinterpret_cast&lt;double*&gt;

Probleme mit reinterpret_cast<double*>