Umwandlung von 8 Bytes zu Integer 64 bits.

Johnny2005

Hallo,
ich habe hier einen Code erstellt, der 8 einzelene Bytes in eine Integer-Zahl mit 64 bits (=8 Bytes) umwandelt. Der Code funktioniert vorwiegend unter MS Visual Studio. Aber er kann auch unter jeden anderem Betriebssystem oder Programmiersprache laufen, wenn dort Int64 unterstützt wird.

Ich bin allerdings für Verbesserungen bezüglich Felxibilität (z. B. beliebger Datentyp) oder Performance offen.

Gruss

Thomas

#include <iostream>
#include<fstream>
#include<limits.h>
using namespace std;
// This code works with Microsoft Visual Studio. It´s not ANSI C++ code.

int main(void)
{
	//Representation of unsigned integer with 64 bit:
	// |64      |56      |48      |40      |32      |24      |16      |8       -> bit number
	// 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 -> binary
	// ---0---0 ---0---0 ---0---0 ---0---0 ---0---0 ---0---0 ---0---0 ---0---0 -> hexadecimal 
	// ---b8--- ---b7--- ---b6--- ---b5--- ---b4--- ---b3--- ---b2--- ---b1--- -> Byte number
	// 8 Bytes with 'b8' as the highest and 'b1' with the lowest byte.
	const unsigned __int64 uInt64Max = ULLONG_MAX  ; /*maximum unsigned __int64 value */
	unsigned __int64 n64Result = uInt64Max;
	unsigned __int64 b8, b7, b6, b5, b4, b3, b2, b1; // Be careful ! These variables have to be in the range between 0 and 255 !!!!

	b8 = (unsigned char)255; // Highest Byte (64...55)
	b7 = (unsigned char)255;  
	b6 = (unsigned char)255;
	b5 = (unsigned char)255; 
	b4 = (unsigned char)255; 
	b3 = (unsigned char)255;  
	b2 = (unsigned char)255;
	b1 = (unsigned char)255; // Lowest Byte (8...1)

				   // |64      |56      |48      |40      |32      |24      |16      |8 
	b8 = b8 << 56; // xxxxxxxx 00000000 00000000 00000000 00000000 00000000 00000000 00000000
	b7 = b7 << 48; // 00000000 xxxxxxxx 00000000 00000000 00000000 00000000 00000000 00000000
	b6 = b6 << 40; // 00000000 00000000 xxxxxxxx 00000000 00000000 00000000 00000000 00000000
	b5 = b5 << 32; // 00000000 00000000 00000000 xxxxxxxx 00000000 00000000 00000000 00000000
	b4 = b4 << 24; // 00000000 00000000 00000000 00000000 xxxxxxxx 00000000 00000000 00000000
	b3 = b3 << 16; // 00000000 00000000 00000000 00000000 00000000 xxxxxxxx 00000000 00000000
	b2 = b2 <<  8; // 00000000 00000000 00000000 00000000 00000000 00000000 xxxxxxxx 00000000
	//b1              00000000 00000000 00000000 00000000 00000000 00000000 00000000 xxxxxxxx

	cout << "b8= " << b8 << " b7= " << b7 << " b6= " << b6 << " b5= " << b5
		 << "b4= " << b4 << " b3= " << b3 << " b2= " << b2 << " b1= " << b1 << endl;

	n64Result = b8 + b7 + b6 + b5 + b4 + b3 + b2 + b1;

	cout << "result: n64Result= " << n64Result << endl;

	cin.get();

	return 0;
}

Mario Sandler

Wenns funktioniert ists ja ok.
Du könntest das script noch für andere compiler bereitsstellen die vielleicht nicht _int64 sonder long long int als 64bit typ benutzen.
Mit präprozessoranweisugen geht das ganz gut.

Man könnte das ganze noch in nen array packen der dann ne komplizierte schleife durchläuft, in meinen Augen wirds dann aber nicht schöner.

const unsigned __int64 uInt64Max = ULLONG_MAX  ; /*maximum unsigned __int64 value */
    unsigned __int64 n64Result = uInt64Max;

Da könnte man der variabel auch direkt ULLONG_MAX zuweisen.

//EDIT
achja man könnte die zahlen ja auch vom user eingeben lassen.
dann hätte das script mehr sinn.

Michael E.

Johnny2005 schrieb:

Ich bin allerdings für Verbesserungen bezüglich Felxibilität (z. B. beliebger Datentyp) [...] offen.

Das macht man mit Templates. Hier mal ein kleiner Vorgeschmack, wie man so etwas lösen könnte (ich geh mal davon aus, dass du dich noch nie mit Templates beschäftigt hast):

#include <stdexcept>

template<class SourceType, class TargetType>
class Converter
{
public:
    template<int ArraySize>
    static TargetType Convert(SourceType source[ArraySize])
    {
    	if(ArraySize > SizeRelation)
            throw std::invalid_argument("Array too big");
    	TargetType result = TargetType();

    	for(int i = SizeRelation - 1; i >= 0; --i)
    		result += source[i] << (SizeRelation - i - 1) * 8;

        return result;
    }

private:
    static const unsigned int SizeRelation = sizeof(TargetType)/sizeof(SourceType);
    Converter();
};

// Anwendung
#include <iostream>

int main()
{
	unsigned char a[] = { 5, 7, 9, 4};

	unsigned int e = Converter<unsigned char, unsigned int>::Convert<4>(a);

	std::cout << e;
}

Edit: Sicherer gemacht.