Ich soll für eine 32-Bit-Zahl ein Teilwort extrahieren. Über eine Tastatureingabe soll ich das Startbit auswählen können und über eine weitere Tastatureingabe soll ich die die Anzahl Bits eingeben können die mit extrahiert werden sollen. Meine bisherige Überlegung findet ihr unten im Code:

#include<iostream>
using namespace std;

int main()
{
    unsigned int bit;
    int s, n, erg;
    int config_byte;

    int a;

    /*
    cout << "Bitte den Startwert s eingeben: s= ";
    cin >> s;

    cout << "Bitte die Anzahl der zu Extrahierenden Bits eingeben: n= ";
    cin >> n;
    */

    bit = 123456789;

    config_byte = 64;

    a = bit & config_byte;

    cout << a;

system("pause");
return 0;    
}

Das Problem daran ist nur, wenn ich nun quasi die erste Stelle meines max. 32-Bit langen Wortes maskieren möchte (mit a = bit & config_byte), dann gibt mir cout << a; 64 aus, was ja dem config_byte entspricht, aber nicht dem maskierten Bit; also entweder eine 1 oder eine 0. Was ist da falsch? Ich mach doch eigentlich nix falsches, oder?

Achja, ich darf nur logische Operatoren benutzen und keine Schleifen oder ähnliches.

Könnt ihr mir weiterhelfen?

#include<iostream>
using namespace std;

int main()
{
    unsigned int config_byte;
    unsigned int s, n, erg;
    unsigned int mask;

    int a;

    /*
    cout << "Bitte den Startwert s eingeben: s= ";
    cin >> s;

    cout << "Bitte die Anzahl der zu Extrahierenden Bits eingeben: n= ";
    cin >> n;
    */

    config_byte = 0xFFFFFFFF;

    //Verschiebung

    mask = 128;

    a = config_byte & mask;

    cout << a;

system("pause");
return 0;    
}

Ich möchte erst mal richtig maskieren können was mir im moment noch nicht gelingt. Danach kann ich mich ja um die extraktion eines Bits kümmern...

0xFF = 11111111
  64 = 01000000

0xFF & 64 = 01000000 = 64

Fehler verstanden?

Der compiler liefert mir eine 64 weil eben 01000000 einer 64 entspricht. Aber wie bringe ich ihn dazu, dass er mir eben nur eine 1 oder 0 auswirft?

int eins_oder_null = (config_byte & mask)? 1 : 0;

Das Startbit setze ich jetzt so:

cin >> s;

    x = a & (1 << s);
    z = x >> s;

Ich bekomme danach je nach dem eine 1 oder 0. Jetzt hab ich allerdings noch das problem, dass ich nicht weiß wie ich ohne Schleifen aus einer 32-bit langen Zahl ab einem Startbit (s) z.B. eine n-lange Bitkette "rausschneide". Irgendwie kann doch das gar nicht gehen, oder?

int int32 = ....;
int start = ...;
int num = ...;

int mask = (1<<num)-1;
int result = (int32 >> start) & mask;

mfg Martin

1111111111111

>> 0000011111111
<< 1111111111000
&  -------------
   0000011111000

mask0 = 0xFFFFFFFF;

    mask1 = mask0 >> (31 - s);
    mask2 = mask0 << (31 - (s + n));

    mask = mask1 & mask2;

Stimmt das so? Was meint ihr?

#include<iostream>
using namespace std;

int main()
{
    unsigned int config_byte;
    unsigned int s, n, erg, x;
    unsigned int mask0, mask1, mask2, mask, anzahl;

    cout << "Bitte den Startwert s eingeben: s= ";
    cin >> s;

    cout << "Bitte die Anzahl der zu Extrahierenden Bits eingeben: n= ";
    cin >> n;

    config_byte = 0xF5C23D21;

    //Erstellen der Maske aufgrund der Benutzereingaben
    mask0 = 0xFFFFFFFF;

    mask1 = mask0 >> (31 - s);
    mask2 = mask0 << (31 - (s - n));
    mask = mask1 & mask2;

    x = config_byte & mask;

    anzahl = 31 - (s - n);
    erg = x >> anzahl;

    cout << erg;

system("pause");
return 0;    
}

Das cout am Schluss liefert nicht das gewünschte Ergebnis... Wenn ich z.B. für s eine 11 (=12. Stelle der 32-Bit-Zahl) und für n eine 4 (um 4 Stellen zu maskieren) eingebe, dann liefert mir cout keine 13 (welche ja in Hex für ein D steht), sondern eine 0. Besser gesagt, er liefert mir für unterschiedliche Werte immer eine 0...

Was mach ich da noch falsch?

So der Grundgedanke dahiner kann doch gar nicht so falsch sein, oder?

Ich hab mir mal jetzt gedanken dazu gemacht und das so aufgezogen:

mask0 = 0xFFFFFFFF;
    
    mask1 = mask0 >> (31 - s);
    mask2 = mask0 << (31 - (s + n));
    
    mask = mask1 & mask2;

Stimmt das so? Was meint ihr?

Soll das jemand kapieren? Um eine Maske zu bekommen mit n gesetzten Bits, schreibe einfach

(1<<n) -1;

Dann shifte des dahin wo Du willst und gut ist.

Mann macht's doch ned so komplexe Lösungen, die dann eh ned funktionieren.

mfg Martin

sorry, aber dein codeschnipsel verstehe ich nicht...

Wo ist das Problem? Das ist doch simpel:

1 << 7 = 10000000
10000000 - 1 = 1111111

1 << 2 = 100
100-1 = 11

Ist jetzt der Groschen gefallen?

mfg Martin

Um die erste Zeil zu erstellen muss ich doch sagen: mask >> (32 - s); wie soll's denn sonst auch gehen.

Um die zweite Zeile zu erstellen muss ich doch auch sagen: mask0 << (32 - (s - (n-1)));

Keine Ahnung wie's anders gehen soll und schon gleich nicht wie das mit so 'nem kurzen Code wie dem hier gehen soll: (1<<n) -1;

1 << 7 = 10000000
10000000 - 1 = 1111111

1 << 2 = 100
100-1 = 11

Ist jetzt der Groschen gefallen?

mfg Martin

Sorry ich kapiers nicht...

EDIT: das obige beispiel verstehe ich jetzt schon aber ich kanns nicht auf mein Problem übertragen...

damit ich weiß an welche stelle ich nach links shiften muss, dass genau 4 bits ausmaskiert werden muss ich halt auch wieder berechnen indem ich sag: (32 - (s - (n-1)))

aber genau dann funzts nicht. wie das mit deinem beispiel gehen soll ist mir überhaupt nicht klar.

Wo ist das Problem? Das ist doch simpel:

1 << 7 = 10000000
10000000 - 1 = 1111111

1 << 2 = 100
100-1 = 11

Ist jetzt der Groschen gefallen?

mfg Martin

Sorry ich kapiers nicht...

EDIT: das obige beispiel verstehe ich jetzt schon aber ich kanns nicht auf mein Problem übertragen...

Du willst doch n hintereinander liegende Bits. Dazu brauchst Du eine Maske mit genau n hintereinander liegenden Bits. Du mußt nur noch die Maske dahin schieben, wo Du sie willst:

unsigned int maske = (1<<n)-1;

Wenn Du die Bits beim höchstwertigen anfängst zu zählen und dort mit 1 anfängst, geht das so:

maske <<= (33-start-n)

normalerweise fängt man aber beim niedrigsten mit 0 an zu zählen. Dann geht das so:

maske <<= start;

Ergänzung:
So normalerweise will man dann aber, daß die maskierten Bits wieder an unterster Stelle stehen. Daher sollte man die Quelle shiften und mit den n bits der Maske maskieren und nicht die Maske shiften. Das erreichst Du letztendlich mit meinem ersten Lösungsvorschlag.

mfg Martin

1100011001010001

Davon möchte ich jetzt die 7., 8., 9., ausmaskiert haben. Meine Stellen beginnen bei 1 und gehen in diesem Fall bis 12.

Dann schreibe ich:

mask = (1 << 10)-1;

jetzt ist bis zur 9. Stelle maskiert. Und nun?

mask1 = (1 >> 6)-1;

Muss ich da jetzt ebenfalls ein -1 schreiben?

mask1 = (1 << n)-1;
mask2 = (1 >> s)-1;

den punkt s kann ich anshiften. mit n wird aber nur gegeben WIEVIELE bits maskiert werden sollen. und die wievielte stelle das nun eben in abhängigkeit von n sind, das MUSS man doch ausrechnen...

Ich hab eine solch Zahl gegeben:

1100011001010001

Davon möchte ich jetzt die 7., 8., 9., ausmaskiert haben. Meine Stellen beginnen bei 1 und gehen in diesem Fall bis 12.

Dann schreibe ich:

mask = (1 << 10)-1;

jetzt ist bis zur 9. Stelle maskiert. Und nun?

Also ich habe jetzt 16 Bits gezählt.

1234567890123456
1100011001010001

Du willst doch nur 3 Bits. Warum erzeugst Du dann eine Maske mit 10 Bits?

mask = (1<<3)-1;
mask <<= 7;

mfg Martin

wahrscheinlich liegts auch daran weil ich es mir nicht vorstellen kann... gibts da nicht irgendwo eine schöne visualisierung wie man solche verdammten shifts macht?

Das ist doch nicht schwer:

(1<<3) - 1 = 0000000000000111;
0000000000000111 << 1 = 0000000000001110;
0000000000000111 << 2 = 0000000000011100;
0000000000000111 << 3 = 0000000000111000;
0000000000000111 << 4 = 0000000001110000;
0000000000000111 << 5 = 0000000011100000;
0000000000000111 << 6 = 0000000011100000;
0000000000000111 << 7 = 0000000111000000;
0000000000000111 << 8 = 0000001110000000;
usw. usf.

mfg Martin