Ist es sicher, -1 zu verwenden, um alle Bits auf true zu setzen?

Ich habe gesehen, dass dieses Muster in C & C ++ häufig verwendet wird.

unsigned int flags = -1;  // all bits are true

Ist dies ein guter tragbarer Weg, um dies zu erreichen? Oder benutzt 0xffffffffoder ~0besser?

Ich empfehle Ihnen, es genau so zu machen, wie Sie es gezeigt haben, da es das einfachste ist. Die Initialisierung -1funktioniert immer , unabhängig von der tatsächlichen Vorzeichendarstellung, während ~sie manchmal ein überraschendes Verhalten aufweist, da Sie den richtigen Operandentyp haben müssen. Nur dann erhalten Sie den höchsten Wert eines unsignedTyps.

Betrachten Sie als Beispiel für eine mögliche Überraschung Folgendes:

unsigned long a = ~0u;

Es wird nicht unbedingt ein Muster mit allen Bits 1 gespeichert a. Es wird jedoch zuerst ein Muster mit allen Bits 1 in einem erstellt unsigned intund dann zugewiesen a. Was passiert, wenn unsigned longmehr Bits vorhanden sind, ist, dass nicht alle davon 1 sind.

Und betrachten Sie diese, die bei der Komplementdarstellung eines Nicht-Zwei fehlschlägt:

unsigned int a = ~0; // Should have done ~0u !

Der Grund dafür ist, dass ~0alle Bits invertiert werden müssen. Invertierung dass Ausbeute wird -1auf eine Ergänzung Maschine zwei (was der Wert ist , die wir brauchen!), Wird aber nicht nachgeben -1auf eine andere Darstellung. Auf der eigenen Komplementmaschine ergibt sich Null. Auf einer Komplementmaschine wird das Obige aauf Null initialisiert .

Das, was Sie verstehen sollten, ist, dass es nur um Werte geht - nicht um Bits. Die Variable wird mit einem Wert initialisiert . Wenn Sie im Initialisierer die Bits der für die Initialisierung verwendeten Variablen ändern, wird der Wert gemäß diesen Bits generiert. Der Wert, den Sie benötigen, um aauf den höchstmöglichen Wert zu initialisieren , ist -1oder UINT_MAX. Die zweite hängt von der Art ab a- Sie müssen ULONG_MAXfür eine verwenden unsigned long. Der erste hängt jedoch nicht von seinem Typ ab, und es ist eine gute Möglichkeit, den höchsten Wert zu erzielen.

Wir sprechen nicht darüber, ob -1alle Bits eins sind (es hat nicht immer). Und wir reden nicht darüber, ob ~0alle Bits eins sind (es hat natürlich).

Wir sprechen jedoch über das Ergebnis der initialisierten flagsVariablen. Und für sie, nur-1 mit jeder Art und Maschine arbeiten.

• unsigned int flags = -1; ist tragbar.
• unsigned int flags = ~0; ist nicht portabel, da es auf einer Zwei-Komplement-Darstellung beruht.
• unsigned int flags = 0xffffffff; ist nicht portabel, da 32-Bit-Ints angenommen werden.

Wenn Sie alle Bits so einstellen möchten, wie es der C-Standard garantiert, verwenden Sie das erste.

Ehrlich gesagt denke ich, dass alle FFFs besser lesbar sind. In Bezug auf den Kommentar, dass es sich um ein Antimuster handelt, würde ich argumentieren, dass Sie sich wahrscheinlich in einer Situation befinden, in der Sie sich sowieso für die Größe der Variablen interessieren, was so etwas wie Boost erfordern würde, wenn Sie sich wirklich darum kümmern, dass alle Bits gesetzt / gelöscht werden :: uint16_t usw.

Ein Weg, um die genannten Probleme zu vermeiden, besteht darin, einfach Folgendes zu tun:

unsigned int flags = 0;
flags = ~flags;

Tragbar und auf den Punkt.

Ich bin mir nicht sicher, ob die Verwendung eines vorzeichenlosen int für Flags in C ++ überhaupt eine gute Idee ist. Was ist mit Bitset und dergleichen?

std::numeric_limit<unsigned int>::max()ist besser, da 0xffffffffdavon ausgegangen wird, dass int ohne Vorzeichen eine 32-Bit-Ganzzahl ist.

unsigned int flags = -1;  // all bits are true

"Ist dies ein guter [,] tragbarer Weg, um dies zu erreichen?"

Tragbar? Ja .

Gut? Umstritten , wie die Verwirrung in diesem Thread zeigt. Klar genug zu sein, dass Ihre Programmierkollegen den Code ohne Verwirrung verstehen können, sollte eine der Dimensionen sein, die wir für guten Code messen.

Diese Methode ist auch anfällig für Compiler-Warnungen . Um die Warnung zu umgehen, ohne Ihren Compiler zu lähmen, benötigen Sie eine explizite Besetzung. Beispielsweise,

unsigned int flags = static_cast<unsigned int>(-1);

Die explizite Besetzung erfordert, dass Sie auf den Zieltyp achten. Wenn Sie auf den Zieltyp achten, vermeiden Sie natürlich die Fallstricke der anderen Ansätze.

Mein Rat wäre, auf den Zieltyp zu achten und sicherzustellen, dass keine impliziten Conversions vorhanden sind. Beispielsweise:

unsigned int flags1 = UINT_MAX;
unsigned int flags2 = ~static_cast<unsigned int>(0);
unsigned long flags3 = ULONG_MAX;
unsigned long flags4 = ~static_cast<unsigned long>(0);

All dies ist korrekt und für Ihre Programmierkollegen offensichtlicher .

Und mit C ++ 11 : Wir können verwenden auto, um all dies noch einfacher zu machen:

auto flags1 = UINT_MAX;
auto flags2 = ~static_cast<unsigned int>(0);
auto flags3 = ULONG_MAX;
auto flags4 = ~static_cast<unsigned long>(0);

Ich halte richtig und offensichtlich für besser als einfach richtig.

Die Konvertierung von -1 in einen vorzeichenlosen Typ wird vom Standard garantiert, um alle zu ergeben. Die Verwendung von ~0Uist im Allgemeinen schlecht, da sie 0einen Typ hat unsigned intund nicht alle Bits eines größeren vorzeichenlosen Typs ausfüllt, es sei denn, Sie schreiben explizit so etwas ~0ULL. Auf vernünftigen Systemen ~0sollte identisch sein mit -1, aber da der Standard Ein-Komplement- und Vorzeichen- / Größen-Darstellungen erlaubt, ist er streng genommen nicht portabel.

Natürlich ist es immer in Ordnung zu schreiben, 0xffffffffwenn Sie wissen, dass Sie genau 32 Bit benötigen, aber -1 hat den Vorteil, dass es in jedem Kontext funktioniert, auch wenn Sie die Größe des Typs nicht kennen, z. B. Makros, die für mehrere Typen funktionieren oder wenn die Größe des Typs je nach Implementierung variiert. Wenn Sie die Art wissen, eine andere sichere Weise alle-onen erhalten die Grenze Makros ist UINT_MAX, ULONG_MAX, ULLONG_MAXetc.

Persönlich benutze ich immer -1. Es funktioniert immer und Sie müssen nicht darüber nachdenken.

Solange Sie #include <limits.h>eines Ihrer Includes haben, sollten Sie nur verwenden

unsigned int flags = UINT_MAX;

Wenn Sie ein langes Stück Bits wollen, können Sie verwenden

unsigned long flags = ULONG_MAX;

Bei diesen Werten werden garantiert alle Wertbits der Ergebnismenge auf 1 gesetzt, unabhängig davon, wie vorzeichenbehaftete Ganzzahlen implementiert sind.

Ja. Wie in anderen Antworten erwähnt, -1ist es am tragbarsten; Es ist jedoch nicht sehr semantisch und löst Compiler-Warnungen aus.

Versuchen Sie diesen einfachen Helfer, um diese Probleme zu lösen:

static const struct All1s
{
    template<typename UnsignedType>
    inline operator UnsignedType(void) const
    {
        static_assert(std::is_unsigned<UnsignedType>::value, "This is designed only for unsigned types");
        return static_cast<UnsignedType>(-1);
    }
} ALL_BITS_TRUE;

Verwendung:

unsigned a = ALL_BITS_TRUE;
uint8_t  b = ALL_BITS_TRUE;
uint16_t c = ALL_BITS_TRUE;
uint32_t d = ALL_BITS_TRUE;
uint64_t e = ALL_BITS_TRUE;

Ich würde das -1-Ding nicht machen. Es ist eher nicht intuitiv (zumindest für mich). Das Zuweisen signierter Daten zu einer nicht signierten Variablen scheint nur eine Verletzung der natürlichen Ordnung der Dinge zu sein.

In deiner Situation benutze ich immer 0xFFFF. (Verwenden Sie natürlich die richtige Anzahl von Fs für die variable Größe.)

[Übrigens sehe ich den -1-Trick sehr selten im realen Code.]

Außerdem, wenn Sie wirklich über die einzelnen Bits in einem vairable kümmern, wäre es sinnvoll sein , die mit fester Breite zu beginnen uint8_t, uint16_t, uint32_tTypen.

Auf Intels IA-32-Prozessoren ist es in Ordnung, 0xFFFFFFFF in ein 64-Bit-Register zu schreiben und die erwarteten Ergebnisse zu erhalten. Dies liegt daran, dass IA32e (die 64-Bit-Erweiterung zu IA32) nur 32-Bit-Sofortnachrichten unterstützt. In 64-Bit-Anweisungen werden 32-Bit -Sofortnachrichten auf 64-Bit vorzeichenerweitert .

Folgendes ist illegal:

mov rax, 0ffffffffffffffffh

Im Folgenden werden 64 1s in RAX eingefügt:

mov rax, 0ffffffffh

Der Vollständigkeit halber werden im Folgenden 32 1s in den unteren Teil von RAX (auch bekannt als EAX) eingefügt:

mov eax, 0ffffffffh

Tatsächlich sind Programme fehlgeschlagen, als ich 0xffffffff in eine 64-Bit-Variable schreiben wollte, und stattdessen habe ich 0xffffffffffffffff erhalten. In C wäre dies:

uint64_t x;
x = UINT64_C(0xffffffff)
printf("x is %"PRIx64"\n", x);

Das Ergebnis ist:

x is 0xffffffffffffffff

Ich dachte, dies als Kommentar zu allen Antworten zu posten, die besagten, dass 0xFFFFFFFF 32 Bit annimmt, aber so viele Leute antworteten, dass ich dachte, ich würde es als separate Antwort hinzufügen.

In der Antwort von litb finden Sie eine sehr klare Erklärung der Probleme.

Mein Widerspruch ist, dass es streng genommen keine Garantien für beide Fälle gibt. Ich kenne keine Architektur, die keinen vorzeichenlosen Wert von "eins weniger als zwei hoch der Anzahl der Bits" darstellt, da alle Bits gesetzt sind, aber hier ist, was der Standard tatsächlich sagt (3.9.1 / 7 plus) Anmerkung 44):

Die Darstellungen von Integraltypen müssen Werte unter Verwendung eines reinen binären Zahlensystems definieren. [Anmerkung 44:] Eine Positionsdarstellung für Ganzzahlen, die die Binärziffern 0 und 1 verwendet, wobei die durch aufeinanderfolgende Bits dargestellten Werte additiv sind, mit 1 beginnen und mit der aufeinanderfolgenden ganzzahligen Potenz von 2 multipliziert werden, außer vielleicht für das Bit mit die höchste Position.

Das lässt die Möglichkeit, dass eines der Bits überhaupt etwas ist.

Obwohl das 0xFFFF(oder 0xFFFFFFFFusw.) möglicherweise leichter zu lesen ist, kann es die Portabilität von Code beeinträchtigen, der ansonsten portabel wäre. Stellen Sie sich zum Beispiel eine Bibliotheksroutine vor, um zu zählen, wie viele Elemente in einer Datenstruktur bestimmte Bits gesetzt haben (die genauen Bits werden vom Aufrufer angegeben). Die Routine kann völlig unabhängig davon sein, was die Bits darstellen, muss aber immer noch eine Konstante "Alle Bits gesetzt" haben. In einem solchen Fall ist -1 weitaus besser als eine Hex-Konstante, da es mit jeder Bitgröße funktioniert.

Die andere Möglichkeit, wenn ein typedefWert für die Bitmaske verwendet wird, wäre die Verwendung von ~ (bitMaskType) 0; wenn Bitmaske nur geschieht , um eine 16-Bit - Typ zu sein, wird dieser Ausdruck nur 16 Bits (auch wenn ‚int‘ sonst 32 Bits sein würde) , aber da 16 Bits alle sein , die erforderlich sind, sollten die Dinge in Ordnung werden zur Verfügung gestellt , dass man verwendet tatsächlich den entsprechenden Typ in der Typumwandlung.

Im Übrigen haben Ausdrücke der Form longvar &= ~[hex_constant]ein unangenehmes Problem, wenn die Hex-Konstante zu groß ist, um in eine zu passen int, aber in eine passt unsigned int. Wenn an int16 Bit ist, dann longvar &= ~0x4000;oder longvar &= ~0x10000; löscht ein Bit von longvar, longvar &= ~0x8000;löscht jedoch Bit 15 und alle darüber liegenden Bits. Bei Werten, die passen, intwird der Komplementoperator auf einen Typ angewendet int, aber das Ergebnis wird mit einem Vorzeichen erweitert long, wobei die oberen Bits gesetzt werden. Bei Werten, für die zu groß ist, unsigned intwird der Komplementoperator auf den Typ angewendet long. Werte zwischen diesen Größen wenden jedoch den Komplementoperator auf type an unsigned int, der dann longohne Vorzeichenerweiterung in type konvertiert wird .

Praktisch: Ja

Theoretisch: Nein.

-1 = 0xFFFFFFFF (oder welche Größe auch immer ein Int auf Ihrer Plattform hat) gilt nur für die Zweierkomplementarithmetik. In der Praxis wird es funktionieren, aber es gibt ältere Maschinen (IBM-Mainframes usw.), auf denen Sie ein tatsächliches Vorzeichenbit anstelle einer Zweierkomplementdarstellung haben. Ihre vorgeschlagene ~ 0-Lösung sollte überall funktionieren.

Wie andere bereits erwähnt haben, ist -1 der richtige Weg, um eine Ganzzahl zu erstellen, die in einen vorzeichenlosen Typ konvertiert wird, wobei alle Bits auf 1 gesetzt sind. Das Wichtigste in C ++ ist jedoch die Verwendung korrekter Typen. Daher lautet die richtige Antwort auf Ihr Problem (einschließlich der Antwort auf die von Ihnen gestellte Frage):

std::bitset<32> const flags(-1);

Dies enthält immer genau die Anzahl der benötigten Bits. Es konstruiert a, std::bitsetwobei alle Bits aus den gleichen Gründen wie in anderen Antworten auf 1 gesetzt sind.

Es ist sicherlich sicher, da bei -1 immer alle verfügbaren Bits gesetzt sind, aber ~ 0 gefällt mir besser. -1 macht für einen einfach nicht viel Sinn unsigned int. 0xFF... ist nicht gut, weil es von der Breite des Typs abhängt.

Ich sage:

int x;
memset(&x, 0xFF, sizeof(int));

Dadurch erhalten Sie immer das gewünschte Ergebnis.

Die Nutzung der Tatsache, dass das Zuweisen aller Bits zu einem für einen vorzeichenlosen Typ eins gleichbedeutend damit ist, den maximal möglichen Wert für den angegebenen Typ zu nehmen
und den Umfang der Frage auf alle vorzeichenlosen Ganzzahltypen auszudehnen :

Das Zuweisen von -1 funktioniert für alle vorzeichenlosen Ganzzahltyp (vorzeichenloses int, uint8_t, uint16_t usw.) sowohl für C als auch für C ++.

Alternativ können Sie für C ++ entweder:

1. Einschließen <limits>und verwendenstd::numeric_limits< your_type >::max()
2. Schreiben Sie eine benutzerdefinierte Vorlagenfunktion (dies würde auch eine Überprüfung der Integrität ermöglichen, dh wenn der Zieltyp wirklich ein vorzeichenloser Typ ist).

Der Zweck könnte mehr Klarheit schaffen, da die Zuweisung -1immer einen erklärenden Kommentar erfordern würde.

Eine Möglichkeit, die Bedeutung etwas deutlicher zu machen und dennoch zu vermeiden, dass der Typ wiederholt wird:

const auto flags = static_cast<unsigned int>(-1);

Ja, die gezeigte Darstellung ist sehr korrekt, als ob wir es umgekehrt machen würden. u erfordert einen Operator, der alle Bits umkehrt. In diesem Fall ist die Logik jedoch recht einfach, wenn wir die Größe der ganzen Zahlen in der Maschine berücksichtigen

In den meisten Maschinen beträgt eine Ganzzahl beispielsweise 2 Byte = 16 Bit. Der maximale Wert, den sie enthalten kann, beträgt 2 ^ 16-1 = 65535 2 ^ 16 = 65536

0% 65536 = 0 -1% 65536 = 65535, was 1111 ............. 1 entspricht, und alle Bits werden auf 1 gesetzt (wenn wir die Restklassen mod 65536 berücksichtigen), daher ist es viel geradeaus.

ich vermute

Nein, wenn Sie diese Vorstellung berücksichtigen, ist sie perfekt für vorzeichenlose Ints geeignet und funktioniert tatsächlich

Überprüfen Sie einfach das folgende Programmfragment

int main () {

unsigned int a=2;

cout<<(unsigned int)pow(double(a),double(sizeof(a)*8));

unsigned int b=-1;

cout<<"\n"<<b;

getchar();

return 0;

}}

Antwort für b = 4294967295, wobei -1% 2 ^ 32 auf 4-Byte-Ganzzahlen ist

Daher ist es für vorzeichenlose Ganzzahlen vollkommen gültig

im Falle von Unstimmigkeiten bitte melden