kurze Frage... wie kann ich sicher sein das ein Datentyp Integer IMMER 32 Bit belegt? Auf 32 Bit Maschinen brauch ich da nicht viel zu machen aber was passiert auf 64 Bit Maschinen?

Beste Grüße

typedef unsigned char MyInteger [4];

Gruß, p.

typedef unsigned char MyInteger [4];

Nee, cstdint ist da schon der richtige Ansatz (siehe TR1, Boost).

typedef unsigned char MyInteger [4];

Danke.

MyInteger answer = 42;
std::cout << answer << std::endl;
std::cout << "Ach so ein Sch***. Machen wir's lieber doch gleich richtig." << std::endl;

typedef unsigned char MyInteger [4];

Danke.

Gern geschehen !!

Konrad Rudolph schrieb:

MyInteger answer = 42;
std::cout << answer << std::endl;

Sorry, aber so wird das nichts.

Konrad Rudolph schrieb:

std::cout << "Ach so ein Sch***. Machen wir's lieber doch gleich richtig." << std::endl;

Lass mich mal raten wie ? BOOOOST ?

proggingmania, ist zwar schön und gut, aber du hast dir keine Gedanken zur Speicherung eines 32 Bit Wertes gemacht. Man müsste ihn binär in 4 Teile splitten, um sie dann jeweils in jedes Element des char-Arrays abszuspeichern. Zum Auslesen wieder zusammensetzen, und zusätzlich casten.

Doch, Gedanken habe ich gemacht. Was spricht denn gegen ein elegantes memcpy ?

#include <iostream>
using namespace std;

typedef unsigned char MyInteger [4];

int main()
{
	int x = 12345;
	int* p = NULL;

	MyInteger y;
	memcpy( &y, &x, sizeof( MyInteger ) ); 
	p = (int*)&y;
	cout << "The content at adress " <<  p
				<< " of MyInteger is: " << *p << endl;

	return 0;  
}

Doch, Gedanken habe ich gemacht. Was spricht denn gegen ein elegantes memcpy ?

der gesunde menschenverstand

der gesunde menschenverstand

Kompetente Aussage, voller sachbezogener Argumente

Version ohne memcpy:

typedef unsigned char My32BitInteger[4];

#include <iostream>
using namespace std;

int main()
{
	unsigned x = 4294967295;

	My32BitInteger myInt;

	char* p = (char*)&x;

	myInt[0] = *p;
	myInt[1] = *(p+1);
	myInt[2] = *(p+2);
	myInt[3] = *(p+3);

	cout << *((unsigned*)myInt) << endl;

	unsigned int a = *((unsigned*)myInt);
	cout << a << endl;

	return 0;
}

Die Initialisierung und die Zuweisung empfiehlt sich als eine Funktion auszulagern.
Der ultimative hardboned CPlusplus'ler kapselt sich das freilich in eine Klasse.
Aber generell würde ich da Boost bevorzugen, da braucht man sich um so einen Tinnef keinen Kopp zu machen

Shade Of Mine schrieb:

der gesunde menschenverstand

Kompetente Aussage, voller sachbezogener Argumente

was ist besser?

typedef unsigned char My32BitInteger[4];

#include <iostream>
using namespace std;

int main()
{
	unsigned x = 4294967295;

	My32BitInteger myInt;

	char* p = (char*)&x;

	myInt[0] = *p;
	myInt[1] = *(p+1);
	myInt[2] = *(p+2);
	myInt[3] = *(p+3);

	cout << *((unsigned*)myInt) << endl;

	unsigned int a = *((unsigned*)myInt);
	cout << a << endl;

	return 0;
}

oder

#include <iostream>
using namespace std;

int main()
{
	unsigned x = 4294967295;

	My32BitInteger myInt = x;

	cout << myInt << endl;

	unsigned int a = myInt;
	cout << a << endl;

	return 0;
}

?

was ist besser?

Falsche Frage.
Richtige Frage: Was ist richtig, was ist falsch?

Richtige Antwort: Obiges ist richtig, das untere ist falsch, weil es noch keinen
Zuweisungs- und Ausgabeoperator gibt, was noch zu schreiben wäre.

Mfg B B B

Falsche Frage.
Richtige Frage: Was ist richtig, was ist falsch?

Richtige Antwort: Obiges ist richtig, das untere ist falsch, weil es noch keinen
Zuweisungs- und Ausgabeoperator gibt, was noch zu schreiben wäre.

Mfg B B B

leider falsch mein anonymer freund. zuweisungs und ausgabeoperator ist bereits implementiert. aus gruenden der uebersicht aber nicht gepostet worden

Obiges ist richtig, das untere ist falsch, weil es noch keinen
Zuweisungs- und Ausgabeoperator gibt, was noch zu schreiben wäre.
Mfg B B B

Zuweisungsoperator tut hier gar nicht not, weil der vorhandene genügt.
( Es gibt keine Zeiger auf andere Objekte )

Für die Ausgabe kann man sich den Ausgabeoperator sparen, wenn man einen Konvertierungsoperator schreibt.
Damit ist dann int i = my_integer und ein cout << my_integer möglich.

Mann könnte nun auf die Idee kommen( oder es auch bleiben lassen ),
eine Klasse zu schreiben, die C++ gerechte Operationen auf einem eigens definierten Datentypen
( typedef unsigned char My32BitInteger[4] )
unterstützt:

#include <iostream>
using namespace std;

typedef unsigned char My32BitInteger[4];

class MyInteger
{
	private:
		My32BitInteger myInt;

	public:
		// Konvertierungsoperator
  	operator int();
	// Standardkonstruktor
	MyInteger()
	{
		cout << "Standardkonstruktor" << endl;
		myInt[0] = 0;
		myInt[1] = 0;
		myInt[2] = 0;
		myInt[3] = 0;
	}

	// Konvertierungskonstruktor
	MyInteger( int i )
	{
		cout << "Konvertierungskonstruktor" << endl;
		myInt[0] = *( (char*)&i     );
		myInt[1] = *( (char*)&i + 1 );
		myInt[2] = *( (char*)&i + 2 );
		myInt[3] = *( (char*)&i + 3 );
	}
};

// Konvertierungsoperator
MyInteger:: operator int()
{
 	cout << "Konvertierungsoperator " << endl;  
	return	 *((unsigned*)myInt);
}

int main()
{
	// Konvertierungskonstruktor
	MyInteger my_int( 77777777 );
	cout << my_int << endl;
	// Standardkonstruktor
 	MyInteger my_integer;
	// Konvertierungsoperator
  	int i = my_integer;
	cout << i << endl;
	my_integer = my_int;
	cout << my_integer << endl;
	return 0;
}

Edit: Wechstaben verbuchselt