Rechts-shift mit Nullen am Anfang

Ich versuche zu tun, eine Art Verschiebung nach Links, das wäre Nullen, die am Anfang anstelle von ones. Wenn ich beispielsweise die linke shift -0xff, bekomme ich diese:

0xff << 3 = 11111000

Allerdings, wenn ich rechts verschieben, bekomme ich diese:

0xff >> 3 = 11111111

Gibt es eine operation, die ich verwenden könnte, um das äquivalent von einer Verschiebung nach Links? also ich würde gerne dieses:

00011111

Jede Anregung?

Bearbeiten

Antwort auf die Kommentare, hier ist der code, den ich verwende:

int number = ~0;
number = number << 4;   
std::cout << std::hex << number << std::endl;

number = ~0;
number = number >> 4;
std::cout << std::hex << number << std::endl;

Ausgabe:

fffffff0
ffffffff

Da es scheint, dass im Allgemeinen sollte es funktionieren, ich bin interessiert, warum dieser bestimmten code nicht. Irgendeine Idee?

  • Diese Frage macht keinen Sinn. Sollten Sie nicht das Ergebnis bekommen, das Sie beschreiben, auf einen C-compiler. Poste bitte den aktuellen code.
  • Die 0xff << 3 geben sollte 11111111000 Und die 0xff >> 3 geben sollte 11111
  • Das ist nicht wahr! Wenn der Wert ein Vorzeichen, das ist eigentlich ein korrektes Verhalten gemäß dem C-standard (effektiv, das Vorzeichen-bit wird beibehalten.) Es ist eine Implementierung konkreten Fall.
  • Nein... die Literale in der Frage vom Typ integer, mit Vorzeichen, aber Sie wird positiv sein. Kein Zeichen-bits gesetzt sind, ist nichts negatives. Der C-standard ist nur besorgt, ob der integer negativ ist oder nicht. C11 6.5.7/4 (Links-shift) "If E1 has a signed type and nonnegative value..." "...otherwise, the behavior is undefined." C11 6.5.7/5 (right shift) "If E1 has a signed type and a negative value, the resulting value is implementation-defined."
  • der Grund, es ist keine Implementierung-definiert ist, dass INT_MAX ist garantiert mindestens 2^16-1. So 0xff ist ein positiver Wert des Typs int, und es kann nach Links verschoben werden, die durch 3 ohne überschreitung INT_MAX. Was der Fragesteller beschreibt, ist nicht konform Verhalten, also entweder es ist nicht das, was sein code hat wirklich sonst seine compiler kaputt.
  • Hrm, Ihr seid richtig. Ich dachte (bei 5somethingAM), die 0xff wäre ein signed char aber offensichtlich ist das falsch. Ich mich zurückziehe, meine Vorherige Aussage. Kaffee, dann etwas verschieben.
  • Ich habe bereits meine Frage mit Beispiel-code. Ich bin mit C++, und getestet mit gcc und msvc. Bin ich etwas fehlt?
  • bitte sehen Sie sich den Beispiel-code, den ich verwende.
  • ~0 ist nicht gleich 0xff.

InformationsquelleAutor laurent | 2013-01-18
  1. 10

    Dies ist, wie C und binäre Arithmetik beide arbeiten:

    Wenn du mit der linken shift 0xff << 3 bekommen Sie binäre: 00000000 11111111 << 3 = 00000111 11111000

    Wenn Sie mit der rechten shift - 0xff >> 3 bekommen Sie binäre: 00000000 11111111 >> 3 = 00000000 00011111

    0xff ist ein (signed) int mit dem positiven Wert 255. Da ist es positiv, das Ergebnis der Verschiebung ist es wohl definiert Verhalten in C und C++. Es wird nicht eine beliebige arithmetische Verschiebungen noch irgendeine Art oder schlecht-definierten Verhalten.

    #include <stdio.h>

int main()
{

  printf("%.4X %d\n", 0xff << 3, 0xff << 3);
  printf("%.4X %d\n", 0xff >> 3, 0xff >> 3);

}

    Ausgabe:

    07F8 2040
001F 31

    Damit Sie etwas seltsames in Ihrem Programm, weil es nicht funktioniert wie erwartet. Vielleicht sind Sie mit char-Variablen oder C++ - Zeichen-Literale.

    Quelle: ISO 9899:2011 6.5.7.

    EDIT nach Frage update

    int number = ~0; gibt Sie eine negative Zahl entspricht -1, vorausgesetzt, Zweierkomplement.

    number = number << 4; ruft Undefiniertes Verhalten, da Sie Links-shift einer negativen Zahl. Das Programm implementiert Undefiniertes Verhalten korrekt, da Sie entweder etwas tut, oder gar nichts. Es kann drucken fffffff0 oder möglicherweise drucken Sie ein rosa Elefant, oder es kann die Festplatte formatieren.

    number = number >> 4; ruft in der Implementierung definierte Verhalten. In deinem Fall, dein compiler behält das Vorzeichen-bit. Dies ist bekannt als arithmetic shift, und die arithmetische rechts-Verschiebung funktioniert so, dass der MSB ist gefüllt mit was auch immer-bit-Wert, den es hatte, bevor die Verschiebung. Also, wenn Sie eine negative Zahl, werden Sie erleben, dass das Programm "verschieben in".

    In 99% aller realen Welt Fällen ist es nicht sinnvoll zu verwenden von bit-Operatoren auf zahlen signiert. Daher immer sicherstellen Sie, dass Sie zahlen ohne Vorzeichen, und dass keines der gefährlichen implizite konvertierungsregeln in C/C++ wandelt Sie in zahlen unterzeichnet (für weitere Informationen über gefährliche Konvertierungen finden Sie unter "die integer-promotion-Regeln" und "die üblichen arithmetischen Umwandlungen", viele gute info über diese auf SO).

    EDIT 2, einige Infos aus dem C99-standard ist die Begründung V5 Dokument.10:

    6.5.7 Bitweise shift-Operatoren

    Die Beschreibung der shift-Operatoren in K&R legt nahe, dass eine Verschiebung von einem
    long count zwingen sollte, den linken Operanden erweitert werden, um lange vor
    verlagert wird. Ein intuitiver Praxis, unterstützt durch die C89
    Ausschuss, ist, dass die Art der Schicht-Zählung hat keinerlei Einfluss auf die
    Art das Ergebnis ist.

    RUHIG ÄNDERN IN C89

    Verschiebung durch eine lange zählen nicht mehr zwingt die verschobenen Operanden zu
    lange. Der C89-Ausschuss bekräftigt die Freiheit bei der Umsetzung gewährt
    von K&R in nicht dass der unterzeichnete shift-rechts-operation zu Unterschreiben
    erweitern, da ein solches Erfordernis könnte sich verlangsamen schnelle code-und da
    die Nützlichkeit der Zeichen verlängert verlagert werden, ist verschwindend gering. (Verschieben
    negative Zweierkomplement integer überträgt sich rein rechnerisch richtig Ort ist
    nicht das gleiche wie geteilt durch zwei!)

    • Ja, die lang so sagt. Aber warum? ein. Warum sind Sie UB/ID? und b. Warum werden Sie nicht beide UB / ID? Was ist es über vorzeichenbehaftete zahlen mit nagative Werte?
    • Ich kann nur spekulieren, aber es ist wahrscheinlich, weil die zugrunde liegenden hardware-Anweisungen, die auf assembler-Ebene. Shift-rechts auf eine negative Zahl, wird standardmäßig die assembler-Instruktion für die arithmetische rechts-Verschiebung. Dies kann ausgeführt werden, wie erwartet, denn es macht nur die Nummer kleiner. Der Verlust von Daten ist zu erwarten und vorhergesagt. Aber wenn Sie die linke Umschalttaste, die assembler-Instruktion für die arithmetische Links-Verschiebung "shift out" - bit in einem carry-bit in einem CPU-register, die Sie nicht erreichen können, C.
    • Also der C-compiler kann entweder einfach entsorgen Sie dieses carry-bit, oder es konnte etwas ausgefallenes mit ihm. Was erwartet der Programmierer nicht offensichtlich ist. Auf Zweierkomplement-Systeme, würde die Zahl ändern, in etwas ganz anderes, die Daten bekommen würde, verlagert in das Vorzeichen-bit, es macht einfach keinen Sinn.
    • Fand ich ein bisschen info aus dem standard-Gründe-Dokument, post oben aktualisiert. Ich weiß zu wenig von den ersten K&R de-facto-standard es zu kommentieren, aber. Vielleicht hat jemand anders das liest, könnte es erleuchte uns beide.
    InformationsquelleAutor Lundin
  2. 7

    Wenn Sie explicitilhy shift 0xff, es funktioniert wie erwartet 

    cout << (0xff >> 3) << endl; //31

    Sollte es nur möglich sein, wenn 0xff ist in der Art, signiert, Breite 8 (char und signed char auf gängigen Plattformen).

    So, in gemeinsamer Fall:

    Müssen Sie verwenden Sie unsigned ints

    (unsigned type)0xff

    Rechte shift arbeitet als division durch 2(mit Rundung nach unten, wenn ich das richtig verstanden habe).

    So, wenn man 1 als erstes bit haben Sie negative Wert und nach der Teilung ist es negative wieder.

    • Ich von Ihnen positiv bewertet werden, aber wirklich nur ein wenig mehr text. wie, warum es den Unterschied machen.
    • 0xffu Werken statt des cast.
    • Ich verstehe das nicht beantworten. 0xff ist äquivalent zu schreiben (signed int)255. Es gibt nichts in der ursprünglichen post-Einstellung ein Zeichen zu bits. 0xFF >> 3 ist, 0x1F, die positive Zahl 31.
    • Rechte shift funktioniert nicht als division! Die Rundung ist anders.
    • Beachten Sie, dass Sie müssen nur diese für die Werte von 0xff nur, wenn Sie in einem signed char geben - sonst 0xff hat einen nicht-negativen Wert (255). Ich denke, dies sei ausdrücklich erwähnt, denn ich habe Menschen gesehen, die verwirrt und denken, dass 0xff hat einen negativen Wert in Kontexten, wo es nicht.
    InformationsquelleAutor RiaD
  3. 5

    Den beiden Arten von rechts-shift denen du sprichst, sind sogenannte Logische Verschiebung und Arithmetic Shift. C und C++ Einsatz von logischen shift für vorzeichenlose Ganzzahlen und die meisten Compiler verwenden arithmetische Verschiebung für eine Ganzzahl, aber das ist nicht garantiert durch die Norm Bedeutung, dass der Wert des rechts verschieben einer negativen signed int ist, ist die Implementierung definiert.

    Da Sie eine logische Verschiebung, die Sie wechseln müssen, um über eine vorzeichenlose Ganzzahl. Sie können dies tun, indem Sie den Ersatz Ihres Konstanten mit 0xffU.

    • Nein, C und C++ ruft der Implementierung definierte Verhalten wenn Sie mit der rechten shift einer negativen Zahl. Es gibt keine Garantien, dass das Ergebnis keinen Sinn macht, oder, dass es dargestellt werden kann, wie eine korrekt formatierte negative Zahl. Wenn Sie mit der linken shift einer negativen Zahl, die Sie aufrufen zu undefiniertem Verhalten.
    • Prüfungen standard. Ja, du hast Recht, die Art der Verschiebung wird durch die Implementierung definiert. Es ist nur meistens einen arithmetischen shift. Ich aktualisiert meine Antwort.
    • können Sie erläutern, oder zeigen Sie auf std.
    • Ja, habe ich geschrieben eine Antwort auf meine eigenen. Als Faustregel gilt, wenn Sie bitweise Operatoren C nicht weiß, oder Pflege der Programmierer beabsichtigte Darstellung der Inhalte. Es ist einfach manipuliert die bits. Zum Beispiel, ob das Ergebnis der rechts-shift eines signierten Nummer passiert, um am Ende in einer Weise, die Sinn macht oder nicht, hängt von der compiler.
    InformationsquelleAutor Jack Aidley
  4. 3

    Zu erklären, Ihre echten code, den Sie müssen nur den C++ - Versionen der Zitate aus dem C-standard, dass Lundin gab in den Kommentaren:

    int number = ~0;
number = number << 4;

    Undefiniertes Verhalten. [expr.shift] sagt

    Den Wert von E1 << E2 E1 Links verschoben E2 bit-Positionen; geräumt
    bits sind null-gefüllt. Wenn E1 hat einen unsigned-Typ, der Wert der
    Ergebnis ist E1 × 2E2, reduziert modulo einer mehr als der maximale Wert
    darstellbar in der Ergebnis-Typ. Ansonsten wenn E1 eine signierte geben
    und nicht-negativen Wert    , und E1×2E2 ist darstellbar in der Folge
    geben, dann ist der resultierende Wert; ansonsten ist das Verhalten
    undefined    .

    number = ~0;
number = number >> 4;

    Implementierung-definiert das Ergebnis, in diesem Fall Ihrer Umsetzung gab Sie einen arithmetischen shift:

    Den Wert von E1 >> E2 E1 rechts-verschoben, E2-bit-Positionen. Wenn E1 hat
    ein unsigned-Typ, oder wenn E1 hat ein signed-Typ und einen nicht-negativen Wert,
    der Wert das Ergebnis ist der ganzzahlige Teil des Quotienten
    E1/2E2. Wenn E1 eine signierte geben und einen negativen Wert, die resultierende
    Wert wird durch die Implementierung festgelegt

    Sollten Sie eine unsigned Typ:

    unsigned int number = -1;
number = number >> 4;
std::cout << std::hex << number << std::endl;

    Ausgabe:

    0x0fffffff
    • Die C11 und C++11-standards scheinen 100% identisch in Ihrer Beschreibung der shift-Operatoren.
    • ja, ich wollte nicht zu bedeuten, das die Regeln (oder auch text) unterschiedlich sind. Es ist nur so, dass der Fragende hat da erklärt in einem Kommentar, dass Sie mit C++, zuvor war es unklar.
    InformationsquelleAutor Steve Jessop
  5. 1

    Meine 5 Cent hier...
    Ich stehe vor genau dem gleichen problem wie dieses.lau! Ich habe einige oberflächliche Forschung auf dies und das sind meine Ergebnisse:

    typedef unsigned int Uint;
#define U31 0x7FFFFFFF
#define U32 0xFFFFFFFF

printf ("U31 right shifted: 0x%08x\n", (U31 >> 30));
printf ("U32 right shifted: 0x%08x\n", (U32 >> 30));

Output:
U31 right shifted: 0x00000001 (expected)
U32 right shifted: 0xffffffff (not expected)

    Scheint es (in Ermangelung jemand mit detaillierten Kenntnissen), dass der C-compiler in XCode für Mac OS X v5.0.1 behält sich das MSB als carry-bit, dass bekommt zog zusammen mit jeder Schicht.

    Etwas störend, das Gegenteil ist NICHT wahr:-

    #define ST00 0x00000001
#define ST01 0x00000002

printf ("ST00 left shifted: 0x%08x\n", (ST00 << 30));
printf ("ST01 left shifted: 0x%08x\n", (ST01 << 30));

Output:
ST00 left shifted: 0x40000000
ST01 left shifted: 0x80000000

    Ich Stimme völlig mit den Menschen vor, die behaupten, dass die Vorzeichen der Operanden hat keinen Einfluss auf das Verhalten der shift-operator.

    Kann jemand alle vergossen Licht auf die Spezifikation für die Posix4 Implementierung von C? Ich fühle mich, eine definitive Antwort kann dort ausruhen.

    In der Zwischenzeit, es scheint, dass die einzige Lösung ist ein Konstrukt, das entlang der folgenden Zeilen;-

    #define CARD2UNIVERSE(c) (((c) == 32) ? 0xFFFFFFFF : (U31 >> (31 - (c))))

    Dieser Werke - Leidig aber notwendig.

    InformationsquelleAutor VectorVictor
Schreibe einen Kommentar