Bitweises lesen von Daten

[The Incredible Fufialk]

Hat jemand eine Idee, wie ich die einzelnen Bits aus einem Datenwort auslesen kann? Oder gibt es noch einen kleinere Datentyp als short?

Bisher lese ich meine Daten folgendermaßen in eine Struktur ein:

ifl.seekg(z*sizeof(short), ios::beg); // Sprung zur gewünschten Stelle

ifl.read((char*)&Tab[i].wertb32, sizeof(short)); // Einlesen des Wertes in die Struktur

z++;

Das ganze läuft als Schleife ab, da ich den Ablauf der Werte im File kenne. Jetzt will ich aber nicht die komplette Zahl auslesen, sondern jedes Bit einzeln, um mir eine switch-case Schleife zu ersparen, in der ich die Dezimalwerte in die Binärkombination umwandel.

[The Incredible Fufialk]

So habe mich schon mal ein wenig schlau gemacht, und folgenden Ansatz gefunden. Leider jedoch noch nit mit dem gewünschten Ergebnis:

ifl.seekg(z*sizeof(short), ios::beg);

ifl.read((char*)&Tab[i].message, sizeof(short));

(Tab[i].message & 0x00)&Tab[i].bit0;

(Tab[i].message & 0x10)&Tab[i].bit1;

(Tab[i].message & 0x20)&Tab[i].bit2;

(Tab[i].message & 0x30)&Tab[i].bit3;

(Tab[i].message & 0x40)&Tab[i].bit4;

(Tab[i].message & 0x50)&Tab[i].bit5;

(Tab[i].message & 0x60)&Tab[i].bit6;

(Tab[i].message & 0x70)&Tab[i].bit7;

(Tab[i].message & 0x80)&Tab[i].bit8;

(Tab[i].message & 0x90)&Tab[i].bit9;

(Tab[i].message & 0xA0)&Tab[i].bit10;

(Tab[i].message & 0xB0)&Tab[i].bit11;

(Tab[i].message & 0xC0)&Tab[i].bit12;

(Tab[i].message & 0xD0)&Tab[i].bit13;

(Tab[i].message & 0xE0)&Tab[i].bit14;

(Tab[i].message & 0xF0)&Tab[i].bit15;

z++;

Als ergebnis möchte ich nur die Nullen und Einsen angezeigt bekommen, aus denen mein short message zusammengesetzt ist.

Also zum Beispiel:

Message = 55

Bit0 = 1

Bit1 = 1

Bit2 = 1

Bit3 = 0

Bit4 = 1

Bit5 = 1

Bit6 = 0

usw. bis bit15. Sieht jemand den Fehler?

[The Incredible Fufialk]

So, ich hab das Problem gelöst, allerdings auf eine sehr unkonventionelle und umständliche Weise. Vielleicht hat ja noch jemand einen Tipp, wie es eleganter geht. Ich rechne jetzt jede Potenz von hand aus, also:

if (Tab[i].message - 32768 >= 0)

{

Tab[i].bit15 = 1;

Tab[i].message = Tab[i].message - 32768;

}

else

{

Tab[i].bit15 = 0;

}

if (Tab[i].message - 16384 >= 0)

{

Tab[i].bit14 = 1;

Tab[i].message = Tab[i].message - 16384;

}

else

{

Tab[i].bit14 = 0;

}

usw. bis bit0

Wie gesagt, nicht sehr elegant, aber erfolgreich. Ich hatte zwischenzeitlich folgenden Ansatz verfolgt, der aber leider nicht das korrekte Ergebnis brachte, aber vielleicht sieht jemand von Euch den Fehler:

Tab[i].bit0 = (Tab[i].message & 0x0100) !=0;

Tab[i].bit1 = (Tab[i].message & 0x0200) !=0;

Tab[i].bit2 = (Tab[i].message & 0x0400) !=0;

Tab[i].bit3 = (Tab[i].message & 0x0800) !=0;

Tab[i].bit4 = (Tab[i].message & 0x1000) !=0;

Tab[i].bit5 = (Tab[i].message & 0x2000) !=0;

Tab[i].bit6 = (Tab[i].message & 0x4000) !=0;

Tab[i].bit7 = (Tab[i].message & 0x8000) !=0;

Tab[i].bit8 = (Tab[i].message & 0x0001) !=0;

Tab[i].bit9 = (Tab[i].message & 0x0002) !=0;

Tab[i].bit10 = (Tab[i].message & 0x0004) !=0;

Tab[i].bit11 = (Tab[i].message & 0x0008) !=0;

Tab[i].bit12 = (Tab[i].message & 0x0010) !=0;

Tab[i].bit13 = (Tab[i].message & 0x0020) !=0;

Tab[i].bit14 = (Tab[i].message & 0x0040) !=0;

Tab[i].bit15 = (Tab[i].message & 0x0080) !=0;

Danke und Frohe Pfingsten schon mal.

[Crush]

Es gäbe noch char (8 Bit)

ifl.seekg(z*sizeof(short), ios::beg);

ifl.read((char*)&Tab[i].message, sizeof(short));

(Tab[i].message & 0x0001)&Tab[i].bit0;

(Tab[i].message & 0x0002)&Tab[i].bit1;

(Tab[i].message & 0x0004)&Tab[i].bit2;

(Tab[i].message & 0x0008)&Tab[i].bit3;

(Tab[i].message & 0x0010)&Tab[i].bit4;

(Tab[i].message & 0x0020)&Tab[i].bit5;

(Tab[i].message & 0x0040)&Tab[i].bit6;

(Tab[i].message & 0x0080)&Tab[i].bit7;

(Tab[i].message & 0x0100)&Tab[i].bit8;

(Tab[i].message & 0x0200)&Tab[i].bit9;

(Tab[i].message & 0x0400)&Tab[i].bit10;

(Tab[i].message & 0x0800)&Tab[i].bit11;

(Tab[i].message & 0x1000)&Tab[i].bit12;

(Tab[i].message & 0x2000)&Tab[i].bit13;

(Tab[i].message & 0x4000)&Tab[i].bit14;

(Tab[i].message & 0x8000)&Tab[i].bit15;

z++;

[/PHP]

[realisticer]

Morgen,

falls es von Interesse ist, so ist man etwas flexibler:

template<size_t bitfieldSize>

struct bits {

	size_t bit : bitfieldSize;

	void write(ostream& out) const {

         for(int i = bitfieldSize; i >= 0; --i)

             if(bit & (1 << i))

                 out<<"1";

             else

                 out<<"0";

    }


    bits& operator<<(const std::string& data) {

        memcpy(this, data.c_str(), min(bitfieldSize, data.size()));

        return *this;

    }


    bits& operator<<(const long& data) {

        memcpy(this, &data, min(bitfieldSize, sizeof(data)));

        return *this;

    }


    bits& operator<<(const double& data) {

        memcpy(this, &data, min(bitfieldSize, sizeof(data)));

        return *this;

    }

};


template<size_t bitfieldSize>

ostream& operator<<(ostream& out, const bits<bitfieldSize>&  {

	b.write(out);

	return out;

}

[/PHP]

Als kleines Beispielprogramm:

[PHP]
int main() {
const char* text = "test";
bits<32> bit;
bit << text;
cout<<bit<<endl;
size_t i = 4;
bit << static_cast<long>(i);
cout<<bit<<endl;
}

mfg

realisticer

[realisticer]

Da faellt mir noch auf: sizeof(data) muss mit 8 multipliziert werden

mfg

realisticer