Perché C non consente la concatenazione di stringhe quando si utilizza l'operatore condizionale?

Il codice seguente viene compilato senza problemi:

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

Tuttavia, questo non compila:

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

Qual è il motivo?

Secondo lo Standard C (5.1.1.2 Fasi di traduzione)

1 La precedenza tra le regole di sintassi della traduzione è specificata dalle seguenti fasi 6)

6. I token letterali stringa adiacenti vengono concatenati.

E solo dopo

7. I caratteri spazi bianchi che separano i token non sono più significativi. Ogni token di pre-elaborazione viene convertito in un token. I token risultanti vengono analizzati sintatticamente e semanticamente e tradotti come un'unità di traduzione .

In questa costruzione

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

non ci sono token letterali stringa adiacenti. Quindi questa costruzione non è valida.

Secondo lo standard C11, capitolo §5.1.1.2, concatenazione di stringhe letterali adiacenti:

I token letterali stringa adiacenti vengono concatenati.

avviene in fase di traduzione . D'altro canto:

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

coinvolge l'operatore condizionale, che viene valutato in fase di esecuzione . Quindi, in fase di compilazione, durante la fase di traduzione, non sono presenti stringhe letterali adiacenti, quindi la concatenazione non è possibile. La sintassi non è valida e quindi segnalata dal compilatore.

Per approfondire un po 'la parte del perché , durante la fase di preelaborazione, le stringhe letterali adiacenti vengono concatenate e rappresentate come una singola stringa letterale (token). La memoria viene allocata di conseguenza e il valore letterale stringa concatenato viene considerato come una singola entità (un valore letterale stringa).

D'altra parte, in caso di concatenazione in fase di esecuzione, la destinazione dovrebbe avere memoria sufficiente per contenere la stringa concatenata letterale , altrimenti non sarà possibile accedere all'output concatenato previsto . Ora, in caso di stringhe letterali , sono già allocate in memoria in fase di compilazione e non possono essere estese per adattarsi a ulteriori input in ingresso o aggiunti al contenuto originale. In altre parole, non sarà possibile accedere (presentare) al risultato concatenato come una singola stringa letterale . Quindi, questo costrutto è intrinsecamente errato.

Cordiali saluti, per run-time stringa ( non letterali ) concatenazione, abbiamo la funzione di libreria strcat()che concatena due stringhe . Avviso, la descrizione menziona:

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

La strcat()funzione aggiunge una copia della stringa a cui punta s2(incluso il carattere null di terminazione) alla fine della stringa a cui puntas1 . Il carattere iniziale di s2sovrascrive il carattere null alla fine di s1. [...]

Quindi, possiamo vedere, s1è una stringa , non una stringa letterale . Tuttavia, poiché il contenuto di s2non viene alterato in alcun modo, può benissimo essere una stringa letterale .

La concatenazione di stringhe letterali viene eseguita dal preprocessore in fase di compilazione. Non c'è modo per questa concatenazione di essere a conoscenza del valore di test, che non è noto finché il programma non viene effettivamente eseguito. Pertanto, questi valori letterali stringa non possono essere concatenati.

Poiché il caso generale è che non avresti una costruzione come questa per i valori noti in fase di compilazione, lo standard C è stato progettato per limitare la funzionalità di auto-concatenazione al caso più semplice: quando i letterali sono letteralmente uno accanto all'altro .

Ma anche se non definisse questa restrizione in quel modo, o se la restrizione fosse costruita in modo diverso, il tuo esempio sarebbe comunque impossibile da realizzare senza rendere la concatenazione un processo di runtime. E, per questo, abbiamo le funzioni di libreria come strcat.

Perché C non ha stringtipo. I valori letterali stringa vengono compilati in charmatrici, a cui fa riferimento un char*puntatore.

C consente di combinare letterali adiacenti in fase di compilazione , come nel primo esempio. Il compilatore C stesso ha una certa conoscenza delle stringhe. Ma queste informazioni non sono presenti in fase di esecuzione e quindi la concatenazione non può avvenire.

Durante il processo di compilazione, il tuo primo esempio viene "tradotto" in:

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

Nota come le due stringhe vengono combinate in un singolo array statico dal compilatore, prima che il programma venga eseguito.

Tuttavia, il tuo secondo esempio è "tradotto" in qualcosa di simile:

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));
}

Dovrebbe essere chiaro il motivo per cui questo non viene compilato. L'operatore ternario ?viene valutato a runtime, non in fase di compilazione, quando le "stringhe" non esistono più in quanto tali, ma solo come semplici chararray, referenziati da char*puntatori. A differenza dei valori letterali stringa adiacenti , i puntatori char adiacenti sono semplicemente un errore di sintassi.

Se vuoi davvero che entrambi i rami producano costanti di stringa in fase di compilazione da scegliere in fase di esecuzione, avrai bisogno di una macro.

#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;
}

Qual è il motivo?

Il codice che utilizza l'operatore ternario sceglie in modo condizionale tra due stringhe letterali. Indipendentemente dalle condizioni note o sconosciute, non possono essere valutate in fase di compilazione, quindi non possono essere compilate. Anche questa dichiarazione printf("Hi" (1 ? "Bye" : "Goodbye"));non si compilerebbe. Il motivo è spiegato in profondità nelle risposte sopra. Un'altra possibilità di rendere valida per la compilazione una dichiarazione del genere utilizzando l'operatore ternario , coinvolgerebbe anche un tag di formato e il risultato dell'istruzione dell'operatore ternario formattato come argomento aggiuntivo per printf. Anche in questo caso, la printf()stampa darebbe l'impressione di "aver concatenato" quelle stringhe solo durante e fin dal runtime .

#include <stdio.h>

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

In printf("Hi" "Bye");hai due array consecutivi di char che il compilatore può trasformare in un singolo array.

In printf("Hi" (test ? "Bye" : "Goodbye"));hai un array seguito da un puntatore a char (un array convertito in un puntatore al suo primo elemento). Il compilatore non può unire una matrice e un puntatore.

Per rispondere alla domanda, andrei alla definizione di printf. La funzione printf si aspetta const char * come argomento. Qualsiasi stringa letterale come "Hi" è un const char *; tuttavia un'espressione come (test)? "str1" : "str2"NON è un const char * perché il risultato di tale espressione si trova solo in fase di esecuzione e quindi è indeterminato in fase di compilazione, un fatto che causa debitamente il reclamo del compilatore. D'altra parte, funziona perfettamenteprintf("hi %s", test? "yes":"no")

Questo non viene compilato perché l'elenco dei parametri per la funzione printf è

(const char *format, ...)

e

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

non si adatta all'elenco dei parametri.

gcc cerca di dargli un senso immaginandolo

(test ? "Bye" : "Goodbye")

è un elenco di parametri e si lamenta del fatto che "Hi" non è una funzione.