Warum erlaubt C keine Verkettung von Zeichenfolgen, wenn der bedingte Operator verwendet wird?

Der folgende Code wird problemlos kompiliert:

int main() {
    printf("Hi" "Bye");
}

Dies wird jedoch nicht kompiliert:

int main() {
    int test = 0;
    printf("Hi" (test ? "Bye" : "Goodbye"));
}

Was ist der Grund dafür?

Nach dem C-Standard (5.1.1.2 Übersetzungsphasen)

1 Die Priorität unter den Syntaxregeln für die Übersetzung wird in den folgenden Phasen festgelegt.6)

6. Benachbarte String-Literal-Token werden verkettet.

Und erst danach

7. Leerzeichen, die Token trennen, sind nicht mehr von Bedeutung. Jedes Vorverarbeitungstoken wird in ein Token konvertiert. Die resultierenden Token werden syntaktisch und semantisch analysiert und als Übersetzungseinheit übersetzt .

In dieser Konstruktion

"Hi" (test ? "Bye" : "Goodbye")

Es gibt keine benachbarten String-Literal-Token. Diese Konstruktion ist also ungültig.

Gemäß dem C11-Standard, Kapitel §5.1.1.2, Verkettung benachbarter String-Literale:

Benachbarte String-Literal-Token werden verkettet.

geschieht in der Übersetzungsphase . Andererseits:

printf("Hi" (test ? "Bye" : "Goodbye"));

bezieht den bedingten Operator mit ein, der zur Laufzeit ausgewertet wird . Während der Übersetzungsphase sind während der Übersetzungsphase keine benachbarten Zeichenfolgenliterale vorhanden, daher ist die Verkettung nicht möglich. Die Syntax ist ungültig und wird daher von Ihrem Compiler gemeldet.

Um den Warum- Teil etwas näher zu erläutern , werden während der Vorverarbeitungsphase die benachbarten Zeichenfolgenliterale verkettet und als einzelnes Zeichenfolgenliteral (Token) dargestellt. Der Speicher wird entsprechend zugewiesen und das verkettete Zeichenfolgenliteral wird als eine einzelne Entität (ein Zeichenfolgenliteral) betrachtet.

Auf der anderen Seite sollte das Ziel im Falle einer Laufzeitverkettung über genügend Speicher verfügen, um das verkettete Zeichenfolgenliteral aufzunehmen. Andernfalls kann auf die erwartete verkettete Ausgabe nicht zugegriffen werden. Bei Zeichenfolgenliteralen wird ihnen bereits zur Kompilierungszeit Speicher zugewiesen, und sie können nicht erweitert werden , um weitere eingehende Eingaben in den ursprünglichen Inhalt aufzunehmen oder an diesen anzuhängen . Mit anderen Worten, es gibt keine Möglichkeit, auf das verkettete Ergebnis als einzelnes Zeichenfolgenliteral zuzugreifen (dargestellt) . Dieses Konstrukt ist also von Natur aus falsch.

Nur zur Info, für Laufzeit Zeichenfolge ( nicht Literale ) Verkettung, haben wir die Library - Funktion , strcat()die zwei verkettet Strings . Beachten Sie, dass in der Beschreibung Folgendes erwähnt wird:

char *strcat(char * restrict s1,const char * restrict s2);

Die strcat()Funktion hängt eine Kopie der Zeichenfolge, auf die von zeigt s2(einschließlich des abschließenden Nullzeichens), an das Ende der Zeichenfolge an, auf die von gezeigt wirds1 . Das Anfangszeichen von s2überschreibt das Nullzeichen am Ende von s1. [...]

Wir können also sehen, dass dies s1eine Zeichenfolge ist , kein Zeichenfolgenliteral . Da der Inhalt von s2jedoch in keiner Weise geändert wird, kann es sich durchaus um ein String-Literal handeln .

Die Verkettung von Zeichenfolgenliteralen wird vom Präprozessor zur Kompilierungszeit durchgeführt. Es gibt keine Möglichkeit für diese Verkettung, den Wert von zu kennen test, der erst bekannt ist, wenn das Programm tatsächlich ausgeführt wird. Daher können diese Zeichenfolgenliterale nicht verkettet werden.

Da der allgemeine Fall ist, dass Sie für Werte, die zur Kompilierungszeit bekannt sind, keine solche Konstruktion haben würden, wurde der C-Standard entwickelt, um die automatische Verkettungsfunktion auf den grundlegendsten Fall zu beschränken: wenn die Literale buchstäblich direkt nebeneinander liegen .

Aber selbst wenn diese Einschränkung nicht auf diese Weise formuliert würde oder wenn die Einschränkung anders aufgebaut wäre, wäre Ihr Beispiel immer noch nicht zu realisieren, ohne die Verkettung zu einem Laufzeitprozess zu machen. Und dafür haben wir die Bibliotheksfunktionen wie strcat.

Weil C keinen stringTyp hat. String-Literale werden zu charArrays kompiliert , auf die durch einen char*Zeiger verwiesen wird .

Mit C können benachbarte Literale wie in Ihrem ersten Beispiel zur Kompilierungszeit kombiniert werden . Der C-Compiler selbst hat einige Kenntnisse über Zeichenfolgen. Diese Informationen sind jedoch zur Laufzeit nicht vorhanden, sodass keine Verkettung auftreten kann.

Während des Kompilierungsprozesses wird Ihr erstes Beispiel "übersetzt" in:

int main() {
    static const char char_ptr_1[] = {'H', 'i', 'B', 'y', 'e', '\0'};
    printf(char_ptr_1);
}

Beachten Sie, wie die beiden Zeichenfolgen vom Compiler zu einem einzigen statischen Array kombiniert werden, bevor das Programm jemals ausgeführt wird.

Ihr zweites Beispiel wird jedoch in etwa so "übersetzt":

int main() {
    static const char char_ptr_1[] = {'H', 'i', '\0'};
    static const char char_ptr_2[] = {'B', 'y', 'e', '\0'};
    static const char char_ptr_3[] = {'G', 'o', 'o', 'd', 'b', 'y', 'e', '\0'};
    int test = 0;
    printf(char_ptr_1 (test ? char_ptr_2 : char_ptr_3));
}

Es sollte klar sein, warum dies nicht kompiliert wird. Der ternäre Operator ?wird zur Laufzeit und nicht zur Kompilierungszeit ausgewertet, wenn die "Zeichenfolgen" nicht mehr als solche existieren, sondern nur noch als einfache charArrays, auf die durch char*Zeiger verwiesen wird . Im Gegensatz zu benachbarten Zeichenfolgenliteralen sind benachbarte Zeichenzeiger einfach ein Syntaxfehler.

Wenn beide Zweige wirklich Zeichenfolgenkonstanten zur Kompilierungszeit erzeugen sollen, die zur Laufzeit ausgewählt werden sollen, benötigen Sie ein Makro.

#include <stdio.h>
#define ccat(s, t, a, b) ((t)?(s a):(s b))

int
main ( int argc, char **argv){
  printf("%s\n", ccat("hello ", argc > 2 , "y'all", "you"));
  return 0;
}

Was ist der Grund dafür?

Ihr Code, der den ternären Operator verwendet, wählt bedingt zwischen zwei Zeichenfolgenliteralen. Unabhängig davon, ob eine Bedingung bekannt oder unbekannt ist, kann dies zum Zeitpunkt der Kompilierung nicht ausgewertet werden, sodass keine Kompilierung möglich ist. Auch diese Aussage printf("Hi" (1 ? "Bye" : "Goodbye"));würde nicht kompiliert. Der Grund wird in den obigen Antworten ausführlich erläutert. Eine andere Möglichkeit , eine solche Anweisung unter Verwendung eines ternären Operators zum Kompilieren gültig zu machen , würde auch ein Format-Tag und das Ergebnis der ternären Operator-Anweisung beinhalten, die als zusätzliches Argument für formatiert sind printf. Selbst dann printf()würde der Ausdruck den Eindruck erwecken, diese Zeichenfolgen erst zur Laufzeit und bereits zur Laufzeit "verkettet" zu haben .

#include <stdio.h>

int main() {
    int test = 0;
    printf("Hi %s\n", (test ? "Bye" : "Goodbye")); //specify format and print as result
}

In haben printf("Hi" "Bye");Sie zwei aufeinanderfolgende Arrays von char, die der Compiler zu einem einzigen Array machen kann.

In haben printf("Hi" (test ? "Bye" : "Goodbye"));Sie ein Array, gefolgt von einem Zeiger auf char (ein Array, das in einen Zeiger auf sein erstes Element konvertiert wurde). Der Compiler kann ein Array und einen Zeiger nicht zusammenführen .

Um die Frage zu beantworten, würde ich zur Definition von printf gehen. Die Funktion printf erwartet const char * als Argument. Jedes String-Literal wie "Hi" ist ein const char *; Ein Ausdruck wie z. B. (test)? "str1" : "str2"ist KEIN const char *, da das Ergebnis eines solchen Ausdrucks nur zur Laufzeit gefunden wird und daher zur Kompilierungszeit unbestimmt ist. Dies führt dazu, dass sich der Compiler ordnungsgemäß beschwert. Auf der anderen Seite - das funktioniert einwandfreiprintf("hi %s", test? "yes":"no")

Dies wird nicht kompiliert, da die Parameterliste für die Funktion printf lautet

(const char *format, ...)

und

("Hi" (test ? "Bye" : "Goodbye"))

passt nicht in die Parameterliste.

gcc versucht es zu verstehen, indem es sich das vorstellt

(test ? "Bye" : "Goodbye")

ist eine Parameterliste und beschwert sich, dass "Hi" keine Funktion ist.