Adding newline character to printf() changes code behaviour

Question

For some reason, adding \n to printf() changes the behaviour of below code. The code without \n prints (null) whereas the code with \n leads to Segmentation fault.

Printf.c

#include <stdio.h>

int main(int argc, char* argv[]){
    printf("%s", argv[1]);
}

Printf.c - Output

$ gcc -o Printf Printf.c
$ ./Printf
(null)

Printf_Newline.c

#include <stdio.h>

int main(int argc, char* argv[]){
    printf("%s\n", argv[1]);
}

Printf_Newline.c - Output

$ gcc -o Printf_Newline Printf_Newline.c
$ ./Printf_Newline
Segmentation fault (core dumped)

I am curious to understand the reason behind this.

Who knows what will happen when your code has a bug in it that causes undefined behaviour. Maybe next time you run it, the world will end - best to fix the bugs :) — Chris Turner
– Chris Turner, Commented Aug 17, 2017 at 14:48
@ChrisTurner You think that it's indeed undefined behavior to pass a NULL pointer for a "%s" specifier, that's strictly true but why then did it print (null) in the other case if there is no such string passed to printf()? I think this might be an actual bug somewhere. — Iharob Al Asimi
– Iharob Al Asimi, Commented Aug 17, 2017 at 14:50
@IharobAlAsimi: "why then did it print (null)" because the GNU guys were creative, had free beers, too much time ... whatever. — alk
– alk, Commented Aug 17, 2017 at 14:51

score 55 · Accepted Answer · 2017-08-17 15:00:21Z

55

Both are undefined behavior, so an answer could stop right here.

But there's at least an explanation for the output of (null). This is an extension in glibc (the GNU C library). Passing 0 for %s in printf() is considered undefined in the C standard and therefore could very well result in a crash. The developers of glibc decided to do something meaningful instead.

The reason the second crashes nevertheless is that with the newline, the compiler decides to optimize: Instead of printf("%s\n", argv[1]), it executes puts(argv[1]), which is semantically equivalent according to the C standard, therefore an allowed optimization. But glibcs "(null)-trick" is only implemented in printf().

There's another undefined behavior in your program: You potentially access argv out of bounds. There's no guarantee what value you will find at argv[i] when i > argc. There's a slight chance argc could be 0, so you could experience anything else as well.

edited Aug 17, 2017 at 15:00

answered Aug 17, 2017 at 14:50

user2371524

Sign up to request clarification or add additional context in comments.

10 Comments

haccks Over a year ago

Where did you get this glibc thing? o__O

Toby Speight Over a year ago

It's undefined behaviour only if i > argc (strictly greater, not greater-or-equal) - argv[argc] is guaranteed to be a null pointer. But I don't see any check of argc >= 1 in that program.

alk Over a year ago

"decides to optimize": Nice spot: printf("%d, %s\n", argc, argv[1]); doesn't crash for argc being equal to 1, but prints: 1, (null)<newline> :-)

Ian Abbott Over a year ago

@alk Perhaps if you call execvp with argv[0] set to NULL.

user2371524 Over a year ago

@alk would have to test that, but maybe i can provoke it with char *argv[] = { 0 }; execv("foo", argv);

|

chqrlie · Accepted Answer · 2017-08-17 14:59:34Z

11

The code has undefined behavior in both cases if the program is not given any command line arguments, so anything can happen.

Since you are curious (good for you!), here is a potential explanation for what you observe:

printf("%s\n", argv[1]); can be optimized by the compiler into puts(argv[1]); whereas printf("%s", argv[1]); still invokes printf().
some implementations of printf accept a null pointer as an argument for the %s conversion, hence the output (null).
puts() has undefined behavior for a null pointer, in your case a segmentation fault.

Try compiling both without any optimization (-O0) and see if you get (null) output with and without the \n.

You can play with godbolt's compiler explorer and see how clang changes behavior with -O0, but not gcc.

answered Aug 17, 2017 at 14:59

chqrlie

152k12 gold badges145 silver badges231 bronze badges

2 Comments

Jagan N Over a year ago

Yes, --O0 flag didn't make any change to the behaviour.

chqrlie Over a year ago

@Beginner: it actually depends on your compiler, recent versions of gcc seem to optimize the printf even when told not to with -O0, whereas clang does keep the call to printf().

cs95 · Accepted Answer · 2017-08-17 17:33:19Z

2

Executing with no arguments argv[1] shall be NULL pointer. With argv[1] being NULL

printf("%s", argv[1]);

will invoke undefined behavior.

edited Aug 17, 2017 at 17:33

cs95

406k106 gold badges744 silver badges797 bronze badges

answered Aug 17, 2017 at 14:51

haccks

107k28 gold badges181 silver badges274 bronze badges

Collectives™ on Stack Overflow

Adding newline character to printf() changes code behaviour

3 Answers 3

10 Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

10 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related