Warum unterstützt Java keine vorzeichenlosen Ints?

Warum unterstützt Java keine Ganzzahlen ohne Vorzeichen?

Es scheint mir eine seltsame Auslassung zu sein, da sie es einem ermöglichen, Code zu schreiben, der bei unerwartet großen Eingaben weniger wahrscheinlich zu Überläufen führt.

Darüber hinaus kann die Verwendung von Ganzzahlen ohne Vorzeichen eine Form der Selbstdokumentation sein, da sie darauf hinweisen, dass der Wert, den das Int ohne Vorzeichen enthalten sollte, niemals negativ sein darf.

In einigen Fällen können vorzeichenlose Ganzzahlen für bestimmte Operationen, z. B. die Division, effizienter sein.

Was ist der Nachteil, wenn man diese einbezieht?

Dies ist aus einem Interview mit Gosling und anderen über die Einfachheit:

Gosling: Für mich als Sprachdesigner, den ich heutzutage nicht wirklich als solche bezeichne, bedeutete "einfach", dass J. Random Developer die Spezifikation im Kopf behalten könnte. Diese Definition besagt, dass Java zum Beispiel nicht Java ist - und tatsächlich haben viele dieser Sprachen viele Eckfälle, Dinge, die niemand wirklich versteht. Fragen Sie jeden C-Entwickler nach unsigned, und schon bald stellen Sie fest, dass fast kein C-Entwickler wirklich versteht, was mit unsigned und vorzeichenloser Arithmetik vor sich geht. Solche Dinge machten C komplex. Der sprachliche Teil von Java ist meiner Meinung nach ziemlich einfach. Die Bibliotheken müssen Sie nachschlagen.

Wenn ich zwischen den Zeilen lese, denke ich, dass die Logik ungefähr so ​​war:

• Im Allgemeinen wollten die Java-Designer das Repertoire der verfügbaren Datentypen vereinfachen
• Für alltägliche Zwecke waren sie der Ansicht, dass signierte Datentypen am häufigsten benötigt werden
• Für die Implementierung bestimmter Algorithmen wird manchmal eine vorzeichenlose Arithmetik benötigt, aber die Art von Programmierern, die solche Algorithmen implementieren würden, hätte auch das Wissen, um vorzeichenlose Arithmetik mit vorzeichenbehafteten Datentypen zu "umgehen"

Meistens würde ich sagen, dass es eine vernünftige Entscheidung war. Möglicherweise hätte ich:

• Byte ohne Vorzeichen erstellt oder zumindest signierte / nicht signierte Alternativen, möglicherweise mit unterschiedlichen Namen, für diesen einen Datentyp bereitgestellt (signiert zu machen ist gut für die Konsistenz, aber wann benötigen Sie jemals ein signiertes Byte?)
• 'short' abgeschafft (wann haben Sie zuletzt 16-Bit-Arithmetik mit Vorzeichen verwendet?)

Trotzdem sind Operationen mit vorzeichenlosen Werten bis zu 32 Bit mit ein wenig Kludging nicht allzu schlecht, und die meisten Leute benötigen keine vorzeichenlose 64-Bit-Division oder einen vorzeichenlosen Vergleich.

Dies ist eine ältere Frage, und Pat hat Char kurz erwähnt. Ich dachte nur, ich sollte sie für andere erweitern, die sich das später ansehen werden. Schauen wir uns die primitiven Java-Typen genauer an:

byte - 8-Bit-Ganzzahl mit Vorzeichen

short - 16-Bit-Ganzzahl mit Vorzeichen

int - 32-Bit-Ganzzahl mit Vorzeichen

long - 64-Bit-Ganzzahl mit Vorzeichen

char - 16-Bit-Zeichen (vorzeichenlose Ganzzahl)

Obwohl Arithmetik charnicht unterstützt wird unsigned, kann sie im Wesentlichen als unsignedGanzzahl behandelt werden . Sie müssten explizit arithmetische Operationen zurückverwandeln char, aber es bietet Ihnen die Möglichkeit, unsignedZahlen anzugeben .

char a = 0;
char b = 6;
a += 1;
a = (char) (a * b);
a = (char) (a + b);
a = (char) (a - 16);
b = (char) (b % 3);
b = (char) (b / a);
//a = -1; // Generates complier error, must be cast to char
System.out.println(a); // Prints ? 
System.out.println((int) a); // Prints 65532
System.out.println((short) a); // Prints -4
short c = -4;
System.out.println((int) c); // Prints -4, notice the difference with char
a *= 2;
a -= 6;
a /= 3;
a %= 7;
a++;
a--;

Ja, es gibt keine direkte Unterstützung für vorzeichenlose Ganzzahlen (natürlich müsste ich die meisten meiner Operationen nicht wieder in char umwandeln, wenn es direkte Unterstützung gäbe). Es gibt jedoch sicherlich einen vorzeichenlosen primitiven Datentyp. Ich hätte gerne auch ein Byte ohne Vorzeichen gesehen, aber ich denke, die Speicherkosten zu verdoppeln und stattdessen char zu verwenden, ist eine praktikable Option.

Bearbeiten

Mit JDK8 gibt es neue APIs für Longund, Integerdie Hilfsmethoden für die Behandlung von longund intWerten als vorzeichenlose Werte bereitstellen .

• compareUnsigned
• divideUnsigned
• parseUnsignedInt
• parseUnsignedLong
• remainderUnsigned
• toUnsignedLong
• toUnsignedString

Darüber hinaus bietet Guava eine Reihe von Hilfsmethoden, mit denen ähnliche Aufgaben bei Ganzzahlentypen ausgeführt werden können, um die Lücke zu schließen, die durch den Mangel an nativer Unterstützung für unsignedGanzzahlen entsteht.

Java hat vorzeichenlose Typen oder mindestens einen: char ist ein vorzeichenloser Short. Was auch immer Gosling vorbringt, es ist wirklich nur seine Unwissenheit, warum es keine anderen Typen ohne Vorzeichen gibt.

Auch kurze Typen: Shorts werden ständig für Multimedia verwendet. Der Grund dafür ist, dass Sie 2 Samples in ein einzelnes 32-Bit-Long ohne Vorzeichen einpassen und viele Operationen vektorisieren können. Gleiches gilt für 8-Bit-Daten und vorzeichenloses Byte. Sie können 4 oder 8 Samples zur Vektorisierung in ein Register einfügen.

Sobald mit und ohne Vorzeichen Ints gemischt Dinge in einem Ausdruck starten chaotisch zu bekommen und Sie wahrscheinlich werden Informationen verlieren. Das Beschränken von Java auf signierte Ints klärt die Dinge nur wirklich auf. Ich bin froh, dass ich mich nicht um das gesamte signierte / nicht signierte Geschäft kümmern muss, obwohl ich manchmal das 8. Bit in einem Byte verpasse.

http://skeletoncoder.blogspot.com/2006/09/java-tutorials-why-no-unsigned.html

Dieser Typ sagt, weil der C-Standard Operationen definiert, bei denen vorzeichenlose und vorzeichenbehaftete Ints als vorzeichenlos behandelt werden. Dies könnte dazu führen, dass negativ vorzeichenbehaftete Ganzzahlen in ein großes vorzeichenloses int übergehen und möglicherweise Fehler verursachen.

Ich denke, Java ist in Ordnung, das Hinzufügen von unsignierten würde es ohne großen Gewinn erschweren. Selbst mit dem vereinfachten Ganzzahlmodell wissen die meisten Java-Programmierer nicht, wie sich die grundlegenden numerischen Typen verhalten - lesen Sie einfach das Buch Java Puzzlers zu sehen, welche Missverständnisse Sie möglicherweise haben.

Wie für praktische Ratschläge:

• Wenn Ihre Werte eine beliebige Größe haben und nicht passen int, verwenden Sie long. Wenn sie passen nicht in longGebrauch BigInteger.

• Verwenden Sie die kleineren Typen nur für Arrays, wenn Sie Platz sparen müssen.

• Wenn Sie genau 64/32/16/8 Bits benötigen, verwenden Sie long/ int/ short/ byteund machen Sie sich keine Gedanken mehr über das Vorzeichenbit, außer für Division, Vergleich, Rechtsverschiebung und Casting.

Siehe auch diese Antwort zum Thema "Portieren eines Zufallszahlengenerators von C nach Java".

Mit JDK8 hat es einige Unterstützung für sie.

Trotz Goslings Bedenken sehen wir möglicherweise noch volle Unterstützung für nicht signierte Typen in Java.

Ich weiß, dass dieser Beitrag zu alt ist. Für Ihr Interesse können Sie in Java 8 und höher den intDatentyp jedoch verwenden, um eine vorzeichenlose 32-Bit-Ganzzahl darzustellen, die einen Mindestwert von 0 und einen Höchstwert von 2 ³² −1 hat. Verwenden , um die IntegerKlasse zu verwenden intDatentyp als unsigned integer und statische Methoden wie compareUnsigned(), divideUnsigned()usw. wurde die hinzugefügt IntegerKlasse , um die arithmetischen Operationen für ganze Zahlen ohne Vorzeichen zu unterstützen.

Ich habe Geschichten gehört, dass sie in der Nähe der ursprünglichen Java-Version enthalten sein sollten. Eiche war der Vorläufer von Java, und in einigen Spezifikationsdokumenten wurden usignierte Werte erwähnt. Leider haben diese es nie in die Java-Sprache geschafft. Soweit jemand herausfinden konnte, wurde er einfach nicht implementiert, wahrscheinlich aus Zeitgründen.

Ich habe einmal einen C ++ - Kurs mit jemandem im C ++ - Standardkomitee besucht, der implizierte, dass Java die richtige Entscheidung getroffen hat, um vorzeichenlose Ganzzahlen zu vermeiden, da (1) die meisten Programme, die vorzeichenlose Ganzzahlen verwenden, genauso gut mit vorzeichenbehafteten Ganzzahlen umgehen können und dies natürlicher ist Die Art und Weise, wie Menschen denken, und (2) die Verwendung von Ganzzahlen ohne Vorzeichen führen zu vielen einfach zu erstellenden, aber schwer zu debuggenden Problemen wie dem Überlauf der Ganzzahlarithmetik und dem Verlust signifikanter Bits beim Konvertieren zwischen vorzeichenbehafteten und vorzeichenlosen Typen. Wenn Sie fälschlicherweise 1 mit vorzeichenbehafteten Ganzzahlen von 0 subtrahieren, stürzt Ihr Programm häufig schneller ab und es ist einfacher, den Fehler zu finden, als wenn es sich um 2 ^ 32 - 1 handelt, und Compiler, statische Analysetools und Laufzeitprüfungen müssen dies tun Angenommen, Sie wissen, was Sie tun, da Sie sich für die Verwendung von Arithmetik ohne Vorzeichen entschieden haben. Ebenfalls,

Vor langer Zeit, als der Speicher begrenzt war und die Prozessoren nicht automatisch mit 64 Bit gleichzeitig arbeiteten, zählte jedes Bit viel mehr. Daher war es viel häufiger wichtig, vorzeichenbehaftete oder vorzeichenlose Bytes oder Kurzschlüsse zu haben, und dies war offensichtlich die richtige Entwurfsentscheidung. Heutzutage ist es in fast allen regulären Programmierfällen mehr als ausreichend, nur ein vorzeichenbehaftetes int zu verwenden, und wenn Ihr Programm wirklich Werte verwenden muss, die größer als 2 ^ 31 - 1 sind, möchten Sie oft sowieso nur ein langes. Wenn Sie erst einmal Longs verwendet haben, ist es noch schwieriger, einen Grund zu finden, warum Sie mit 2 ^ 63 - 1 positiven ganzen Zahlen wirklich nicht auskommen können. Wann immer wir zu 128-Bit-Prozessoren gehen, wird es noch weniger ein Problem sein.

Ihre Frage lautet "Warum unterstützt Java keine vorzeichenlosen Ints"?

Und meine Antwort auf Ihre Frage lautet, dass Java möchte, dass alle primitiven Typen: Byte , Zeichen , Kurz , Int und Lang genau wie in Assembly als Byte , Wort , Dword und Qword behandelt werden und die Java-Operatoren signiert werden Operationen für alle primitiven Typen außer char , aber nur für char sind sie nur 16-Bit ohne Vorzeichen.

Daher wird angenommen, dass statische Methoden auch für 32- und 64-Bit- Operationen ohne Vorzeichen sind .

Sie benötigen die letzte Klasse, deren statische Methoden für die vorzeichenlosen aufgerufen werden können Operationen .

Sie können diese letzte Klasse erstellen, sie beliebig nennen und ihre statischen Methoden implementieren.

Wenn Sie keine Ahnung haben, wie die statischen Methoden implementiert werden sollen, klicken Sie auf diesen Link kann Ihnen helfen.

Meiner Meinung nach ist Java C ++ überhaupt nicht ähnlich , wenn es weder vorzeichenlose Typen noch unterstützt Überladen von Operatoren denke ich, dass Java als völlig andere Sprache als C ++ und C behandelt werden sollte.

Es ist übrigens auch im Namen der Sprachen völlig anders.

Daher empfehle ich in Java nicht, Code ähnlich wie C ++ einzugeben, und ich empfehle überhaupt nicht, Code ähnlich C ++ einzugeben, da Sie dann in Java nicht in der Lage sind, das zu tun, was Sie als Nächstes in C ++ tun möchten. dh der Code wird überhaupt nicht mehr C ++ sein und für mich ist es schlecht, so zu codieren, um den Stil in der Mitte zu ändern.

Ich empfehle, statische Methoden auch für die signierten Operationen zu schreiben und zu verwenden, sodass Sie in der Codemischung aus Operatoren und statischen Methoden sowohl für signierte als auch für nicht signierte Operationen nichts sehen, es sei denn, Sie benötigen nur signierte Operationen im Code, und das ist in Ordnung Verwenden Sie nur die Operatoren.

Außerdem empfehle ich, die Verwendung von kurzen , int und langen primitiven Typen zu vermeiden und Wort , Wort und Wort zu verwenden stattdessen zu verwenden, und Sie werden die statischen Methoden für vorzeichenlose Operationen und / oder vorzeichenbehaftete Operationen aufrufen, anstatt Operatoren zu verwenden.

Wenn Sie nur signierte Operationen ausführen und die Operatoren nur im Code verwenden möchten, ist es in Ordnung, diese primitiven Typen short , int und long zu verwenden .

Eigentlich tun es Wort , Wort und Wort nicht existieren in der Sprache, aber Sie können für jede neue Klasse erstellen und mit der Durchführung jeder sollte sehr einfach sein:

Die Klasse Wort hält die primitive Art kurz nur, die Klasse dword den Urtyp hält int nur und die Klasse qword hält den Urtyp lange nur. Jetzt können Sie alle vorzeichenlosen und vorzeichenbehafteten Methoden als statisch oder nicht nach Ihrer Wahl in jeder Klasse implementieren, dh alle 16-Bit-Operationen, sowohl vorzeichenlos als auch signiert, indem Sie der Wortklasse Bedeutungsnamen geben , alle 32-Bit-Operationen sowohl vorzeichenlos als auch signiert durch Angabe von Bedeutungsnamen für die Dword- Klasse und alle 64-Bit-Operationen ohne Vorzeichen und signiert durch Angabe von Bedeutungsnamen für die qword- Klasse.

Wenn Sie nicht gerne zu viele verschiedene Namen für jede Methode angeben, können Sie in Java immer eine Überladung verwenden. Gut zu lesen, dass Java das nicht auch entfernt hat!

Wenn Sie Methoden anstelle von Operatoren für vorzeichenbehaftete 8-Bit-Operationen und Methoden für vorzeichenlose 8-Bit-Operationen ohne Operatoren wünschen, können Sie die Byte- Klasse erstellen (beachten Sie, dass der erste Buchstabe 'B' Großbuchstaben ist, dies ist also nicht der primitives Typbyte ) und implementieren Sie die Methoden in dieser Klasse.

Über das Übergeben von Werten und Übergeben von Referenzen:

Wenn ich mich nicht irre, wie in C #, werden primitive Objekte natürlich als Wert übergeben, aber Klassenobjekte werden natürlich als Referenz übergeben, was bedeutet, dass Objekte vom Typ Byte , Wort , Dword und Qword als Referenz und nicht als Wert übergeben werden standardmäßig. Ich wünschte, Java hätte Strukturobjekte wie C #, so dass alle Bytes , Wörter , Wörter und QWords so implementiert werden könnten, dass sie Struktur statt Klasse sindDaher wurden sie standardmäßig als Wert und nicht standardmäßig als Referenz übergeben, wie jedes Strukturobjekt in C #, wie die primitiven Typen, als Wert und nicht standardmäßig als Referenz, sondern weil Java schlechter ist als C # und wir haben Um damit umzugehen, gibt es nur Klassen und Schnittstellen, die standardmäßig als Referenz und nicht als Wert übergeben werden. Also , wenn Sie weitergeben wollen Byte , Wort , dword und qword Objekte von Wert und nicht nach, wie jede andere Klasse Objekt in Java und auch in C #, müssen Sie einfach die Kopie Konstruktor verwenden und das ist es.

Das ist die einzige Lösung, über die ich nachdenken kann. Ich wünschte nur, ich könnte die primitiven Typen einfach in word, dword und qword eingeben, aber Java unterstützt weder typedef noch die Verwendung überhaupt, im Gegensatz zu C #, das die Verwendung unterstützt , was dem typedef des C entspricht.

Informationen zur Ausgabe:

Für dieselbe Folge von Bits können Sie sie auf verschiedene Arten drucken: Als binär, als Dezimalzahl (wie die Bedeutung von% u in C printf), als Oktal (wie die Bedeutung von% o in C printf), als Hexadezimalzahl (wie) die Bedeutung von% x in C printf) und als Ganzzahl (wie die Bedeutung von% d in C printf).

Beachten Sie, dass C printf den Typ der Variablen, die als Parameter an die Funktion übergeben werden, nicht kennt. Daher kennt printf den Typ jeder Variablen nur von dem char * -Objekt, das an den ersten Parameter der Funktion übergeben wird.

In jeder der Klassen: Byte , Wort , Dword und Qword können Sie die Druckmethode implementieren und die Funktionalität von printf abrufen. Auch wenn der primitive Typ der Klasse signiert ist, können Sie ihn dennoch als nicht signiert drucken, indem Sie einem Algorithmus folgen logische und Verschiebungsoperationen, damit die Ziffern in die Ausgabe gedruckt werden.

Leider zeigt der Link, den ich Ihnen gegeben habe, nicht, wie diese Druckmethoden implementiert werden, aber ich bin sicher, dass Sie nach den Algorithmen suchen können, die Sie zum Implementieren dieser Druckmethoden benötigen.

Das ist alles, was ich auf Ihre Frage beantworten und Ihnen vorschlagen kann.

Weil unsignedTyp rein böse ist.

Die Tatsache, dass in C unsigned - intproduziert, unsignedist noch böser.

Hier ist eine Momentaufnahme des Problems, das mich mehr als einmal verbrannt hat:

// We have odd positive number of rays, 
// consecutive ones at angle delta from each other.
assert( rays.size() > 0 && rays.size() % 2 == 1 );

// Get a set of ray at delta angle between them.
for( size_t n = 0; n < rays.size(); ++n )
{
    // Compute the angle between nth ray and the middle one.
    // The index of the middle one is (rays.size() - 1) / 2,
    // the rays are evenly spaced at angle delta, therefore
    // the magnitude of the angle between nth ray and the 
    // middle one is: 
    double angle = delta * fabs( n - (rays.size() - 1) / 2 ); 

    // Do something else ...
}

Haben Sie den Fehler schon bemerkt? Ich gebe zu, ich habe es erst gesehen, nachdem ich mit dem Debugger eingestiegen bin.

Da nes sich um einen vorzeichenlosen Typ handelt, wird size_tder gesamte Ausdruck n - (rays.size() - 1) / 2als ausgewertet unsigned. Dieser Ausdruck soll eine vorzeichenbehaftete Position des ndritten Strahls vom mittleren Strahl sein: Der erste Strahl vom mittleren Strahl auf der linken Seite hätte die Position -1, der erste Strahl auf der rechten Seite hätte die Position +1 usw. Danach Wenn deltaich den abs-Wert nehme und mit dem Winkel multipliziere, erhalte ich den Winkel zwischen dem nStrahl und dem mittleren.

Leider enthielt der obige Ausdruck für mich das Böse ohne Vorzeichen, und anstatt beispielsweise -1 zu bewerten, bewertete er 2 ^ 32-1. Die anschließende Konvertierung doublebesiegelte den Fehler.

Nach ein oder zwei Fehlern, die durch den Missbrauch von unsignedArithmetik verursacht wurden, muss man sich fragen, ob das zusätzliche Bit, das man bekommt, die zusätzliche Mühe wert ist. Ich versuche so weit wie möglich, die Verwendung von unsignedTypen in der Arithmetik zu vermeiden , obwohl ich sie immer noch für nicht-arithmetische Operationen wie Binärmasken verwende.

Es gibt ein paar Juwelen in der 'C'-Spezifikation, die Java aus pragmatischen Gründen fallen ließ, die sich aber langsam mit der Nachfrage der Entwickler zurückziehen (Schließungen usw.).

Ich erwähne eine erste, weil sie mit dieser Diskussion zusammenhängt; das Festhalten von Zeigerwerten an vorzeichenlose Ganzzahlarithmetik. Und in Bezug auf dieses Thread-Thema die Schwierigkeit, die Semantik ohne Vorzeichen in der signierten Welt von Java beizubehalten.

Ich würde vermuten, wenn man ein Alter Ego von Dennis Ritchie dazu bringen würde, Goslings Designteam zu beraten, hätte es vorgeschlagen, Signed eine "Null im Unendlichen" zu geben, so dass alle Adressoffset-Anforderungen zuerst ihre ALGEBRAISCHE RINGGRÖSSE addieren würden, um negative Werte zu vermeiden.

Auf diese Weise kann ein auf das Array geworfener Offset niemals ein SEGFAULT erzeugen. Zum Beispiel in einer gekapselten Klasse, die ich RingArray of Doubles nenne und die ein vorzeichenloses Verhalten benötigt - im Kontext einer "selbstrotierenden Schleife":

// ...
// Housekeeping state variable
long entrycount;     // A sequence number
int cycle;           // Number of loops cycled
int size;            // Active size of the array because size<modulus during cycle 0
int modulus;         // Maximal size of the array

// Ring state variables
private int head;   // The 'head' of the Ring
private int tail;   // The ring iterator 'cursor'
// tail may get the current cursor position
// and head gets the old tail value
// there are other semantic variations possible

// The Array state variable
double [] darray;    // The array of doubles

// somewhere in constructor
public RingArray(int modulus) {
    super();
    this.modulus = modulus;
    tail =  head =  cycle = 0;
    darray = new double[modulus];
// ...
}
// ...
double getElementAt(int offset){
    return darray[(tail+modulus+offset%modulus)%modulus];
}
//  remember, the above is treating steady-state where size==modulus
// ...

Das obige RingArray würde niemals von einem negativen Index "bekommen", selbst wenn ein böswilliger Anforderer es versuchen würde. Denken Sie daran, dass es auch viele legitime Anfragen gibt, nach vorherigen (negativen) Indexwerten zu fragen.

NB: Der äußere% -Modul verweist auf legitime Anfragen, während der innere% -Modul offensichtliche Bosheit von Negativen maskiert, die negativer als -modul sind. Sollte dies jemals in einem Java + .. + 9 || erscheinen 8 + .. + spec, dann würde das Problem wirklich zu einem "Programmierer, der sich nicht selbst drehen kann".

Ich bin sicher, dass der sogenannte Java unsigned int 'Mangel' mit dem oben genannten Einzeiler ausgeglichen werden kann.

PS: Nur um der obigen RingArray-Verwaltung einen Kontext zu geben, hier eine Kandidaten-Set-Operation, die mit der obigen Get-Element-Operation übereinstimmt:

void addElement(long entrycount,double value){ // to be called only by the keeper of entrycount
    this.entrycount= entrycount;
    cycle = (int)entrycount/modulus;
    if(cycle==0){                       // start-up is when the ring is being populated the first time around
        size = (int)entrycount;         // during start-up, size is less than modulus so use modulo size arithmetic
        tail = (int)entrycount%size;    //  during start-up
    }
    else {
        size = modulus;
        head = tail;
        tail = (int)entrycount%modulus; //  after start-up
    }
    darray[head] = value;               //  always overwrite old tail
}

Ich kann mir eine unglückliche Nebenwirkung vorstellen. In in Java eingebetteten Datenbanken beträgt die Anzahl der IDs, die Sie mit einem 32-Bit-ID-Feld haben können, 2 ^ 31, nicht 2 ^ 32 (~ 2 Milliarden, nicht ~ 4 Milliarden).

Der Grund IMHO ist, dass sie zu faul sind / waren, um diesen Fehler zu implementieren / zu korrigieren. Es ist einfach absurd zu behaupten, dass C / C ++ - Programmierer unsigned, struct, union, bit flag ... nicht verstehen.

Sie haben mit einem einfachen / bash / java-Programmierer gesprochen, der kurz davor stand, a la C zu programmieren, ohne diese Sprache wirklich zu kennen, oder Sie sprechen nur aus Ihrem eigenen Kopf heraus. ;)

Wenn Sie sich jeden Tag mit dem Format von Datei oder Hardware befassen, beginnen Sie sich zu fragen, was zum Teufel sie gedacht haben.

Ein gutes Beispiel wäre hier der Versuch, ein vorzeichenloses Byte als selbstrotierende Schleife zu verwenden. Für diejenigen unter Ihnen, die den letzten Satz nicht verstehen, wie um alles in der Welt Sie sich selbst als Programmierer bezeichnen.

DC