Warum sind C-Zeichen-Literale Ints anstelle von Zeichen?

In C ++ , sizeof('a') == sizeof(char) == 1. Dies ist intuitiv sinnvoll, da 'a'es sich um ein Zeichenliteral handelt und sizeof(char) == 1wie im Standard definiert.

In C jedoch sizeof('a') == sizeof(int). Das heißt, es scheint, dass C-Zeichenliterale tatsächlich ganze Zahlen sind. Weiß jemand warum? Ich kann viele Erwähnungen dieser C-Eigenart finden, aber keine Erklärung dafür, warum sie existiert.

Diskussion zum gleichen Thema

"Genauer gesagt die integralen Beförderungen. In K & R C war es praktisch (?) Unmöglich, einen Zeichenwert zu verwenden, ohne dass er zuerst zu int befördert wurde. Wenn Sie also zuerst die Zeichenkonstante int festlegen, wurde dieser Schritt eliminiert. Es gab und gibt mehrere Zeichen Konstanten wie 'abcd' oder wie viele auch immer in ein int passen. "

Die ursprüngliche Frage lautet "Warum?"

Der Grund dafür ist, dass sich die Definition eines Literalzeichens weiterentwickelt und geändert hat, während versucht wurde, abwärtskompatibel mit vorhandenem Code zu bleiben.

In den dunklen Tagen des frühen C gab es überhaupt keine Typen. Als ich das Programmieren in C zum ersten Mal lernte, wurden Typen eingeführt, aber Funktionen hatten keine Prototypen, um dem Aufrufer die Argumenttypen mitzuteilen. Stattdessen wurde standardisiert, dass alles, was als Parameter übergeben wird, entweder die Größe eines Int hat (dies schließt alle Zeiger ein) oder ein Double.

Dies bedeutete, dass beim Schreiben der Funktion alle Parameter, die nicht doppelt waren, als Ints auf dem Stapel gespeichert wurden, unabhängig davon, wie Sie sie deklariert haben, und der Compiler Code in die Funktion einfügte, um dies für Sie zu erledigen.

Dies machte die Dinge etwas inkonsistent. Als K & R ihr berühmtes Buch schrieb, setzten sie die Regel ein, dass ein Zeichenliteral in jedem Ausdruck immer zu einem int heraufgestuft wird, nicht nur zu einem Funktionsparameter.

Als das ANSI-Komitee C zum ersten Mal standardisierte, änderten sie diese Regel so, dass ein Zeichenliteral einfach ein int war, da dies ein einfacherer Weg war, dasselbe zu erreichen.

Bei der Entwicklung von C ++ mussten alle Funktionen über vollständige Prototypen verfügen (dies ist in C immer noch nicht erforderlich, obwohl es allgemein als bewährte Methode akzeptiert wird). Aus diesem Grund wurde entschieden, dass ein Zeichenliteral in einem Zeichen gespeichert werden kann. Dies hat in C ++ den Vorteil, dass eine Funktion mit einem char-Parameter und eine Funktion mit einem int-Parameter unterschiedliche Signaturen haben. Dieser Vorteil ist bei C nicht der Fall.

Deshalb sind sie unterschiedlich. Evolution...

Ich kenne die spezifischen Gründe nicht, warum ein Zeichenliteral in C vom Typ int ist. Aber in C ++ gibt es einen guten Grund, diesen Weg nicht zu gehen. Bedenken Sie:

void print(int);
void print(char);

print('a');

Sie würden erwarten, dass der Aufruf zum Drucken die zweite Version mit einem Zeichen auswählt. Ein Charakter-Literal als Int zu haben, würde dies unmöglich machen. Beachten Sie, dass in C ++ - Literalen mit mehr als einem Zeichen immer noch der Typ int vorhanden ist, obwohl ihr Wert durch die Implementierung definiert ist. Also, 'ab'hat Typ int, während 'a'hat Typ char.

Mit gcc auf meinem MacBook versuche ich:

#include <stdio.h>
#define test(A) do{printf(#A":\t%i\n",sizeof(A));}while(0)
int main(void){
  test('a');
  test("a");
  test("");
  test(char);
  test(short);
  test(int);
  test(long);
  test((char)0x0);
  test((short)0x0);
  test((int)0x0);
  test((long)0x0);
  return 0;
};

was beim Ausführen gibt:

'a':    4
"a":    2
"":     1
char:   1
short:  2
int:    4
long:   4
(char)0x0:      1
(short)0x0:     2
(int)0x0:       4
(long)0x0:      4

was darauf hindeutet, dass ein Zeichen 8 Bit hat, wie Sie vermuten, aber ein Zeichenliteral ist ein int.

Als C geschrieben wurde, hatte die MACRO-11-Assemblersprache des PDP-11:

MOV #'A, R0      // 8-bit character encoding for 'A' into 16 bit register

Diese Art von Dingen ist in der Assemblersprache weit verbreitet - die niedrigen 8 Bits enthalten den Zeichencode, andere Bits werden auf 0 gelöscht. PDP-11 hatte sogar:

MOV #"AB, R0     // 16-bit character encoding for 'A' (low byte) and 'B'

Dies bot eine bequeme Möglichkeit, zwei Zeichen in die niedrigen und hohen Bytes des 16-Bit-Registers zu laden. Sie können diese dann an eine andere Stelle schreiben und einige Textdaten oder den Bildschirmspeicher aktualisieren.

Die Idee, Zeichen zur Registergröße zu befördern, ist also ganz normal und wünschenswert. Angenommen, Sie müssen 'A' nicht als Teil des fest codierten Opcodes in ein Register eintragen, sondern von einem Ort im Hauptspeicher, der Folgendes enthält:

address: value
20: 'X'
21: 'A'
22: 'A'
23: 'X'
24: 0
25: 'A'
26: 'A'
27: 0
28: 'A'

Wenn Sie nur ein 'A' aus diesem Hauptspeicher in ein Register einlesen möchten, welches würden Sie lesen?

• Einige CPUs unterstützen möglicherweise nur das direkte Einlesen eines 16-Bit-Werts in ein 16-Bit-Register, was bedeuten würde, dass beim Lesen bei 20 oder 22 die Bits von 'X' gelöscht werden müssen, und dies hängt von der Endigkeit der CPU ab müsste in das Byte niedriger Ordnung verschoben werden.

• Einige CPUs erfordern möglicherweise einen speicherausgerichteten Lesevorgang. Dies bedeutet, dass die niedrigste betroffene Adresse ein Vielfaches der Datengröße sein muss: Möglicherweise können Sie von den Adressen 24 und 25 lesen, nicht jedoch von den Adressen 27 und 28.

Ein Compiler, der Code generiert, um ein 'A' in das Register zu bringen, kann es daher vorziehen, ein wenig zusätzlichen Speicher zu verschwenden und den Wert als 0 'A' oder 'A' 0 zu codieren - abhängig von der Endianität und auch sicherzustellen, dass er richtig ausgerichtet ist ( dh nicht an einer ungeraden Speicheradresse).

Ich vermute, dass Cs diese Ebene des CPU-zentrierten Verhaltens einfach übernommen haben, indem sie an Zeichenkonstanten gedacht haben, die Registergrößen des Speichers belegen, was die allgemeine Einschätzung von C als "High-Level-Assembler" bestätigt.

(Siehe 6.3.3 auf Seite 6-25 von http://www.dmv.net/dec/pdf/macro.pdf )

Ich erinnere mich, wie ich K & R gelesen und ein Code-Snippet gesehen habe, das jeweils ein Zeichen las, bis es EOF traf. Da alle Zeichen gültige Zeichen für einen Datei- / Eingabestream sind, bedeutet dies, dass EOF kein Zeichenwert sein kann. Der Code hat das gelesene Zeichen in ein int eingefügt, dann auf EOF getestet und dann in ein Zeichen konvertiert, wenn dies nicht der Fall war.

Mir ist klar, dass dies Ihre Frage nicht genau beantwortet, aber es wäre sinnvoll, wenn der Rest der Zeichenliterale sizeof (int) wäre, wenn das EOF-Literal wäre.

int r;
char buffer[1024], *p; // don't use in production - buffer overflow likely
p = buffer;

while ((r = getc(file)) != EOF)
{
  *(p++) = (char) r;
}

Ich habe keine Begründung dafür gesehen (C-Zeichen-Literale sind int-Typen), aber hier ist etwas, was Stroustrup dazu zu sagen hatte (aus Design und Evolution 11.2.1 - Feinkornauflösung):

In C, wie der Typ eines Zeichenliteral solchen 'a'ist int. Überraschenderweise verursacht die Angabe von 'a'Typ charin C ++ keine Kompatibilitätsprobleme. Mit Ausnahme des pathologischen Beispiels sizeof('a')liefert jedes Konstrukt, das sowohl in C als auch in C ++ ausgedrückt werden kann, das gleiche Ergebnis.

Zum größten Teil sollte es also keine Probleme verursachen.

Der historische Grund dafür ist, dass C und sein Vorgänger B ursprünglich auf verschiedenen Modellen von DEC PDP-Minicomputern mit verschiedenen Wortgrößen entwickelt wurden, die 8-Bit-ASCII unterstützten, aber nur Arithmetik für Register ausführen konnten. (Nicht der PDP-11, der später kam.) Frühere Versionen von C wurden intals native Wortgröße der Maschine definiert, und jeder Wert, der kleiner als a ist int, musste erweitert intwerden, um an oder von einer Funktion übergeben zu werden oder in einem bitweisen, logischen oder arithmetischen Ausdruck verwendet, weil die zugrunde liegende Hardware so funktionierte.

Das ist auch der Grund, warum die Regeln für die Ganzzahl-Heraufstufung immer noch besagen, dass jeder Datentyp, der kleiner als ein intist, heraufgestuft wird int. C-Implementierungen dürfen aus ähnlichen historischen Gründen auch die Eins-Komplement-Mathematik anstelle der Zwei-Komplement-Mathematik verwenden. Der Grund dafür, dass Oktalzeichen entkommen und Oktalkonstanten im Vergleich zu Hex erstklassige Bürger sind, liegt ebenfalls darin, dass diese frühen DEC-Minicomputer Wortgrößen hatten, die in Drei-Byte-Blöcke, aber nicht in Vier-Byte-Halbbytes unterteilt werden konnten.

Dies ist das richtige Verhalten, das als "integrale Werbung" bezeichnet wird. Es kann auch in anderen Fällen passieren (hauptsächlich binäre Operatoren, wenn ich mich richtig erinnere).

BEARBEITEN: Nur um sicherzugehen, habe ich meine Kopie von Expert C Programming: Deep Secrets überprüft und bestätigt, dass ein Zeichenliteral nicht mit einem Typ int beginnt . Es ist zunächst vom Typ char , aber wenn es in einem verwendet wird , Ausdruck wird gefördert zu einem int . Folgendes wird aus dem Buch zitiert:

Zeichenliterale haben den Typ int und gelangen dorthin, indem sie die Regeln für die Heraufstufung vom Typ char befolgen. Dies wird in K & R 1 auf Seite 39 zu kurz behandelt, wo es heißt:

Jedes Zeichen in einem Ausdruck wird in ein int konvertiert. Beachten Sie, dass alle Gleitkommazahlen in einem Ausdruck in double konvertiert werden. Da ein Funktionsargument ein Ausdruck ist, finden Typkonvertierungen auch statt, wenn Argumente an Funktionen übergeben werden: in Insbesondere werden char und short int, float wird double.

Ich weiß es nicht, aber ich denke, es war einfacher, es so zu implementieren, und es war nicht wirklich wichtig. Erst in C ++, als der Typ bestimmen konnte, welche Funktion aufgerufen werden würde, musste sie behoben werden.

Das wusste ich wirklich nicht. Bevor es Prototypen gab, wurde alles, was schmaler als ein int war, in ein int konvertiert, wenn es als Funktionsargument verwendet wurde. Das kann Teil der Erklärung sein.

Dies ist nur tangential zur Sprachspezifikation, aber in der Hardware hat die CPU normalerweise nur eine Registergröße - sagen wir 32 Bit - und wann immer es tatsächlich auf einem Zeichen funktioniert (durch Addieren, Subtrahieren oder Vergleichen), gibt es eine implizite Konvertierung in int, wenn es in das Register geladen wird. Der Compiler sorgt dafür, dass die Zahl nach jeder Operation richtig maskiert und verschoben wird. Wenn Sie beispielsweise 2 zu (vorzeichenloses Zeichen) 254 hinzufügen, wird sie auf 0 anstatt auf 256 umgebrochen, aber im Silizium ist es wirklich ein Int bis Sie es wieder im Speicher speichern.

Es ist eine Art akademischer Punkt, da die Sprache ohnehin einen 8-Bit-Literaltyp hätte angeben können, aber in diesem Fall spiegelt die Sprachspezifikation genauer wider, was die CPU wirklich tut.

(x86-Wonks stellen möglicherweise fest, dass es z. B. ein natives Add-Op gibt, das die Short-Wide-Register in einem Schritt hinzufügt. Innerhalb des RISC-Kerns bedeutet dies jedoch zwei Schritte: Addieren Sie die Zahlen und erweitern Sie das Vorzeichen wie ein Add / Extsh-Paar der PowerPC)