Question: The following code compiles without problems:

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

```

However, this does not compile:

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

```

What is the reason for that?

Answer: 
As per the C11 standard, chapter §5.1.1.2, concatenation of adjacent string literals:

> 
> Adjacent string literal tokens are concatenated.
> 
> 
> 

happens in **translation phase**. On the other hand:

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

```

involves the conditional operator, which is evaluated at **run-time**. So, at compile time, during the translation phase, there are no adjacent string literals present, hence the concatenation is not possible. The syntax is invalid and thus reported by your compiler.

---

To elaborate a bit on the ***why*** part, during the preprocessing phase, the adjacent string literals are concatenated and represented as a single *string literal* (token). The storage is allocated accordingly and the concatenated string literal is considered as a *single entity* (one string literal).

On the other hand, in case of run-time concatenation, the destination should have enough memory to hold the concatenated *string literal* otherwise, there will be no way that the *expected* concatenated output can be accessed. Now, in case of *string literals*, they are already allocated memory at compile-time and cannot be *extended* to fit in any more incoming input *into* or *appended to* the original content. In other words, there will be no way that the concatenated result can be accessed (presented) as a single *string literal*. So, this construct in inherently incorrect.

Just FYI, for run-time **string** (*not literals*) concatenation, we have the library function [`strcat()`](http://linux.die.net/man/3/strcat) which concatenates two *strings*. Notice, the description mentions:

> 
> `char *strcat(char * restrict s1,const char * restrict s2);`
> 
> 
> The `strcat()` function appends a copy of the string pointed to by `s2` (including the
>  terminating null character) to the end of the **string pointed to by `s1`**. The initial character
>  of `s2` overwrites the null character at the end of `s1`. [...]
> 
> 
> 

So, we can see, the `s1` is a **string**, not a **string literal**. However, as the content of `s2` is not altered in any way, it can very well be a *string literal*.
To answer the question - I would go to the definition of printf. The function printf expects **const char\*** as argument. Any string literal such as "Hi" is a const char\*; however an expression such as `(test)? "str1" : "str2"` is NOT a const char\* because the result of such expression is found only at run-time and hence is indeterminate at compile time, a fact which duly causes the compiler to complain. On the other hand - this works perfectly well `printf("hi %s", test? "yes":"no")`