Pourquoi C n'autorise-t-il pas la concaténation de chaînes lors de l'utilisation de l'opérateur conditionnel?

Le code suivant se compile sans problème:

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

Cependant, cela ne compile pas:

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

Quelle est la raison de ceci?

Selon la norme C (5.1.1.2 Phases de traduction)

1 La priorité parmi les règles de syntaxe de traduction est spécifiée par les phases suivantes.6)

6. Les jetons littéraux de chaîne adjacents sont concaténés.

Et seulement après ça

7. Les espaces blancs séparant les jetons ne sont plus significatifs. Chaque jeton de prétraitement est converti en jeton. Les jetons résultants sont analysés syntaxiquement et sémantiquement et traduits en tant qu'unité de traduction .

Dans cette construction

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

il n'y a pas de jetons littéraux de chaîne adjacents. Cette construction est donc invalide.

Selon la norme C11, chapitre §5.1.1.2, concaténation de littéraux de chaîne adjacents:

Les jetons littéraux de chaîne adjacents sont concaténés.

se passe en phase de traduction . D'autre part:

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

implique l'opérateur conditionnel, qui est évalué au moment de l' exécution . Ainsi, au moment de la compilation, pendant la phase de traduction, il n'y a pas de littéraux de chaîne adjacents présents, par conséquent la concaténation n'est pas possible. La syntaxe est invalide et donc signalée par votre compilateur.

Pour élaborer un peu sur la partie pourquoi , pendant la phase de prétraitement, les littéraux de chaîne adjacents sont concaténés et représentés sous la forme d'un littéral de chaîne unique (jeton). Le stockage est alloué en conséquence et le littéral de chaîne concaténé est considéré comme une seule entité (un littéral de chaîne).

D'autre part, en cas de concaténation au moment de l'exécution, la destination doit avoir suffisamment de mémoire pour contenir la chaîne de caractères concaténée , sinon, il n'y aura aucun moyen d' accéder à la sortie concaténée attendue . Maintenant, en cas de littéraux de chaîne , ils sont déjà attribués mémoire à la compilation et ne peuvent être étendues pour tenir dans une entrée plus entrant dans ou ajoutés au contenu original. En d'autres termes, il n'y aura aucun moyen que le résultat concaténé puisse être accédé (présenté) comme une chaîne littérale unique . Donc, cette construction est intrinsèquement incorrecte.

Juste Pour votre information, pour l' exécution chaîne ( non littéraux ) concaténation, nous avons la fonction de bibliothèque strcat()qui concatène deux chaînes . Remarquez, la description mentionne:

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

La strcat()fonction ajoute une copie de la chaîne pointée par s2(y compris le caractère nul de fin) à la fin de la chaîne pointée pars1 . Le caractère initial de s2remplace le caractère nul à la fin de s1. [...]

Ainsi, nous pouvons voir que le s1est une chaîne , pas une chaîne littérale . Cependant, comme le contenu de s2n'est en aucun cas modifié, il peut très bien s'agir d'une chaîne littérale .

La concaténation de chaînes littérales est effectuée par le préprocesseur au moment de la compilation. Il n'y a aucun moyen pour cette concaténation de connaître la valeur de test, qui n'est connue que lorsque le programme s'exécute réellement. Par conséquent, ces littéraux de chaîne ne peuvent pas être concaténés.

Parce que le cas général est que vous n'auriez pas une construction comme celle-ci pour les valeurs connues au moment de la compilation, le standard C a été conçu pour restreindre la fonction d'auto-concaténation au cas le plus élémentaire: lorsque les littéraux sont littéralement côte à côte .

Mais même s'il ne formulait pas cette restriction de cette manière, ou si la restriction était construite différemment, votre exemple serait toujours impossible à réaliser sans faire de la concaténation un processus d'exécution. Et, pour cela, nous avons les fonctions de bibliothèque telles que strcat.

Parce que C n'a pas de stringtype. Les littéraux de chaîne sont compilés en chartableaux, référencés par un char*pointeur.

C permet aux littéraux adjacents d'être combinés au moment de la compilation , comme dans votre premier exemple. Le compilateur C lui-même a des connaissances sur les chaînes. Mais ces informations ne sont pas présentes au moment de l'exécution et la concaténation ne peut donc pas se produire.

Pendant le processus de compilation, votre premier exemple est "traduit" en:

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

Notez comment les deux chaînes sont combinées en un seul tableau statique par le compilateur, avant que le programme ne s'exécute.

Cependant, votre deuxième exemple est "traduit" en quelque chose comme ceci:

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

Il devrait être clair pourquoi cela ne compile pas. L'opérateur ternaire ?est évalué à l'exécution, non à la compilation, lorsque les "chaînes" n'existent plus en tant que telles, mais uniquement en tant que simples chartableaux, référencés par des char*pointeurs. Contrairement aux chaînes littérales adjacentes, les pointeurs char adjacents sont simplement une erreur de syntaxe.

Si vous voulez vraiment que les deux branches produisent des constantes de chaîne au moment de la compilation à choisir au moment de l'exécution, vous aurez besoin d'une 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;
}

Quelle est la raison de ceci?

Votre code utilisant l'opérateur ternaire choisit conditionnellement entre deux littéraux de chaîne. Quelle que soit la condition connue ou inconnue, cela ne peut pas être évalué au moment de la compilation, donc il ne peut pas compiler. Même cette déclaration printf("Hi" (1 ? "Bye" : "Goodbye"));ne serait pas compilée. La raison est expliquée en profondeur dans les réponses ci-dessus. Une autre possibilité de rendre une telle déclaration en utilisant un opérateur ternaire valide à compiler , impliquerait également une balise de format et le résultat de l'instruction d'opérateur ternaire formaté comme argument supplémentaire à printf. Même dans ce cas, l' printf()impression donnerait l'impression d'avoir "concaténé" ces chaînes uniquement au moment de l' exécution et dès l' exécution .

#include <stdio.h>

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

Dans printf("Hi" "Bye");vous avez deux tableaux consécutifs de char que le compilateur peut transformer en un seul tableau.

Dans printf("Hi" (test ? "Bye" : "Goodbye"));vous avez un tableau suivi d'un pointeur vers char (un tableau converti en un pointeur vers son premier élément). Le compilateur ne peut pas fusionner un tableau et un pointeur.

Pour répondre à la question - j'irais à la définition de printf. La fonction printf attend const char * comme argument. Toute chaîne littérale telle que "Hi" est un const char *; cependant une expression telle que (test)? "str1" : "str2"n'est PAS un const char * parce que le résultat d'une telle expression est trouvé uniquement au moment de l'exécution et est donc indéterminé au moment de la compilation, un fait qui amène dûment le compilateur à se plaindre. D'autre part - cela fonctionne parfaitement bienprintf("hi %s", test? "yes":"no")

Cela ne compile pas car la liste des paramètres de la fonction printf est

(const char *format, ...)

et

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

ne rentre pas dans la liste des paramètres.

gcc essaie de lui donner un sens en imaginant que

(test ? "Bye" : "Goodbye")

est une liste de paramètres, et se plaint que "Hi" n'est pas une fonction.