Hallo Rentner, hallo in die Runde,
den meisten haben wohl schon seit der Schule eine generalisierte Textaufgaben-Allergie. Es war eine ernst gemeinte Frage, in wieweit es in der Arduino-Sprach Umsetzung eine Einschränkung beim char geben könnte, zumal die Doku sagt:
Die Größe des char-Datentyps beträgt mindestens 8 Bit. Es wird empfohlen, char nur zum Speichern von Zeichen zu verwenden. Verwende für einen vorzeichenlosen 1-Byte-Datentyp (8 Bit) den byte-Datentyp.
Was ja nicht ausschließen würde, daß wie in C üblich, dann ein char auch ein Munis vertragen würde. Der Zahlenraum ist in der Docu nicht explizit genannt.
Da braucht man weniger herumflegeln, als mal nachzudenken, ob an der Frage was dran sein könnte.
Hintergrund ist die, bei alten C-Leuten gerne benutzte Strategie des error-Return eines Funktionswertes, zur weiteren Nutzung im aufrufenden Programm, gerne gleich mit entsprechender Error # oder aber eben gerne auch mal als -1.
In der Parameterliste stehen teilweise referenzierte und unreferenzierte Variable unterschiedlichen Typs, was nur auf die nachstehend beschriebene Ungereimtheit abzielt.
Ein Variablen TYPE „BYTE“ ist in C entweder
ein unsigned char mit 8 Bit also decimal 0 .. 255 oder
ein (signed) char mit 8 Bit mit 7 Bit für die „Zahl“ und ein Bit für das Vorzeichen
aber eben in jedem Fall 8 bit lang, wobei der Anwender sich drum kümmern muß was er damit macht.
Eigentlich ist nach ANSI C z.B. eine recht ausführliche Quelle ist das https://archive.org/details/micro-soft-c-5v-0-lang-ref Handbuch von 1984 die ich auch heute noch gerne zum Nachschauen nutze.
Auf Seite 51 steht zu Variablen Typen Fundamentals :
char 1 byte -128 .. 127
int Implementation depending (Arduino 16 Bit also 2 byte)
In der Arduino-Welt scheint der Type char aber einen Haken zu haben.
Nietet man per binärem ODER dem High Byte in sein High Bit eine „1“ , dann werden auf wunderbare Weise aber scheinbar 4 Byte verbraten! Siehe nachstehendes Beispiel.
char CHAR = 0b10000001;
int iCHAR = 0b10000001;
byte ax = 0b10000001;
Serial .println (" defined as: char CHAR = 0b10000001;");
Seria .print (" BIN CHAR = "); **Serial** .println (CHAR, BIN);
Serial .print (" int "); **Serial** .println(int (CHAR), DEC);
Serial .print (" sizeof(CHAR) as char = ");
Serial.print (sizeof(CHAR)); **Serial** .println (" byte");
Serial.println ();
Serial.println (" defined as: int iCHAR = 0b10000001;");
Serial.print (" BIN iCHAR = "); **Serial** .println (iCHAR, BIN);
Serial.print (" int "); **Serial** .println (int (iCHAR), DEC);
Serial.print (" sizeof(iCHAR) as int = ");
Serial.print (sizeof(iCHAR)); **Serial** .println (" byte");
Serial.println ();
Serial.println (" defined as: byte ax = 0b10000001;");
Serial.print (" BIN ax = "); **Serial** .println (ax, BIN);
Serial.print (" int "); **Serial** .println (int (ax), DEC);
Serial.print (" sizeof(ax) ax as byte = ");
Serial.print (sizeof(ax)); **Serial** .println (" byte");
Das wird dann zu:
defined as: char CHAR = 0b10000001;
BIN CHAR = 11111111111111111111111110000001
int -127
sizeof(CHAR) as char = 1 byte
defined as: int iCHAR = 0b10000001;
BIN iCHAR = 10000001
int 129
sizeof(iCHAR) as int = 2 byte
defined as: byte ax = 0b10000001;
BIN ax = 10000001
int 129
sizeof(ax) ax as byte = 1 byte
Beim CHAR-Beispiel meint der Sizeof es wäre 1 Byte lang, pinselt auf dem Serial Monitor aber 4 byte BINär raus.
Was richtigerweise -127 gibt, aber so war CHAR ja nicht vereinbart.
Lehre: will man eine Arduino function als return error einen Wert auf den Heimweg geben, sollte auf das Fehlen des 8ten Bits einer char-Variablen Rücksicht genommen werden, da eben die Implementation des Typs char beim Arduino keine negative werdende Zahl ermöglicht, da der Datentyp nur 7-Bit nutzt also sind nur Zahlen von 0 ... 127 möglich. Schade, würde Platz sparen.
Gruß Bavaricus
