Por que C não permite a concatenação de strings ao usar o operador condicional?

O código a seguir é compilado sem problemas:

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

No entanto, isso não compila:

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

Qual é o motivo disso?

De acordo com o padrão C (5.1.1.2 fases de tradução)

1 A precedência entre as regras de sintaxe de tradução é especificada pelas seguintes fases.6)

6. Os tokens literais de string adjacentes são concatenados.

E só depois disso

7. Os caracteres de espaço em branco que separam os tokens não são mais significativos. Cada token de pré-processamento é convertido em um token. Os tokens resultantes são sintaticamente e semanticamente analisados ​​e traduzidos como uma unidade de tradução .

Nesta construção

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

não há tokens literais de string adjacentes. Portanto, esta construção é inválida.

De acordo com o padrão C11, capítulo §5.1.1.2, concatenação de literais de string adjacentes:

Os tokens literais de string adjacentes são concatenados.

acontece na fase de tradução . Por outro lado:

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

envolve o operador condicional, que é avaliado em tempo de execução . Portanto, em tempo de compilação, durante a fase de tradução, não há literais de string adjacentes presentes, portanto, a concatenação não é possível. A sintaxe é inválida e, portanto, relatada por seu compilador.

Para elaborar um pouco sobre a parte porque , durante a fase de pré-processamento, os literais de string adjacentes são concatenados e representados como um único literal de string (token). O armazenamento é alocado de acordo e o literal de string concatenado é considerado como uma entidade única (um literal de string).

Por outro lado, no caso de concatenação em tempo de execução, o destino deve ter memória suficiente para conter o literal de string concatenado , caso contrário, não haverá nenhuma maneira de acessar a saída concatenada esperada . Agora, no caso de strings literais , eles já estão alocados de memória em tempo de compilação e não pode ser estendido para caber em qualquer entrada de mais de entrada em ou anexado ao conteúdo original. Em outras palavras, não haverá como o resultado concatenado ser acessado (apresentado) como um único literal de string . Portanto, essa construção é inerentemente incorreta.

Apenas para sua informação, para concatenação de string em tempo de execução ( não literais ), temos a função de biblioteca strcat()que concatena duas strings . Observe, a descrição menciona:

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

A strcat()função anexa uma cópia da string apontada por s2(incluindo o caractere nulo de terminação) ao final da string apontada pors1 . O caractere inicial de s2substitui o caractere nulo no final de s1. [...]

Portanto, podemos ver que s1é uma string , não uma string literal . No entanto, como o conteúdo de s2não é alterado de forma alguma, pode muito bem ser um literal de string .

A concatenação de literal de string é executada pelo pré-processador em tempo de compilação. Não há como essa concatenação reconhecer o valor de test, que não é conhecido até que o programa seja realmente executado. Portanto, esses literais de string não podem ser concatenados.

Como o caso geral é que você não teria uma construção como essa para valores conhecidos em tempo de compilação, o padrão C foi projetado para restringir o recurso de autocacatenação ao caso mais básico: quando os literais estão literalmente lado a lado .

Mas mesmo que essa restrição não seja expressa dessa forma, ou se a restrição for construída de forma diferente, seu exemplo ainda seria impossível de realizar sem tornar a concatenação um processo de tempo de execução. E, para isso, temos as funções de biblioteca como strcat.

Porque C não tem stringtipo. Literais de string são compilados em chararrays, referenciados por um char*ponteiro.

C permite que literais adjacentes sejam combinados em tempo de compilação , como em seu primeiro exemplo. O próprio compilador C tem algum conhecimento sobre strings. Mas essas informações não estão presentes no tempo de execução e , portanto, a concatenação não pode acontecer.

Durante o processo de compilação, seu primeiro exemplo é "traduzido" para:

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

Observe como as duas strings são combinadas em um único array estático pelo compilador, antes que o programa seja executado.

No entanto, seu segundo exemplo é "traduzido" para algo assim:

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

Deve ficar claro por que isso não compila. O operador ternário ?é avaliado em tempo de execução, não em tempo de compilação, quando as "strings" não existem mais como tais, mas apenas como charmatrizes simples , referenciadas por char*ponteiros. Ao contrário dos literais de string adjacentes , os ponteiros char adjacentes são simplesmente um erro de sintaxe.

Se você realmente deseja que ambas as ramificações produzam constantes de string de tempo de compilação a serem escolhidas em tempo de execução, você precisará de uma 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 é o motivo disso?

Seu código usando o operador ternário escolhe condicionalmente entre dois literais de string. Não importa a condição conhecida ou desconhecida, isso não pode ser avaliado em tempo de compilação, portanto, não pode ser compilado. Mesmo esta declaração printf("Hi" (1 ? "Bye" : "Goodbye"));não compilaria. O motivo é explicado em detalhes nas respostas acima. Outra possibilidade de fazer tal declaração usando o operador ternário válido para compilar também envolveria uma tag de formato e o resultado da declaração do operador ternário formatado como argumento adicional para printf. Mesmo assim, a printf()impressão daria a impressão de "ter concatenado" essas strings apenas no tempo de execução e logo no início .

#include <stdio.h>

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

Em printf("Hi" "Bye");você tem dois arrays consecutivos de char que o compilador pode transformar em um único array.

Em printf("Hi" (test ? "Bye" : "Goodbye"));você tem uma matriz seguida por um ponteiro para char (uma matriz convertida em um ponteiro para seu primeiro elemento). O compilador não pode mesclar uma matriz e um ponteiro.

Para responder à pergunta - eu iria para a definição de printf. A função printf espera const char * como argumento. Qualquer string literal como "Hi" é um const char *; no entanto, uma expressão como (test)? "str1" : "str2"NÃO é const char * porque o resultado de tal expressão é encontrado apenas em tempo de execução e, portanto, é indeterminado em tempo de compilação, um fato que devidamente faz com que o compilador reclame. Por outro lado - isso funciona perfeitamente bemprintf("hi %s", test? "yes":"no")

Isso não compila porque a lista de parâmetros para a função printf é

(const char *format, ...)

e

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

não cabe na lista de parâmetros.

O gcc tenta dar sentido a isso imaginando que

(test ? "Bye" : "Goodbye")

é uma lista de parâmetros e reclama que "Hi" não é uma função.