What You Will Learn

Prerequisites

• The previous lecture on printf and format specifiers.
• Basic knowledge of the char type and string literals.
• A Linux shell with gcc, od, cat and expand (all standard on Ubuntu).

What Are C Escape Sequences?

Inside a string or character literal, a backslash is a signal to the compiler: “the next character is special, treat the pair as one character”. So \n is written with two keystrokes in your source file but becomes a single byte in your program. For the newline that byte has the value 10.

This conversion happens when the compiler reads your source code, before printf ever runs. printf just receives a string that already contains the real control byte. That is different from format specifiers such as %d, which are interpreted by printf at run time. Keeping this split in mind clears up a lot of confusion: backslashes are for the compiler, percent signs are for printf.

Newline and Tab: The C Escape Sequences You Use Daily

The Newline Character

Without \n, printf keeps writing on the same line, and the shell prompt ends up glued to your last word. Almost every log line you ever print should end with a newline. A bonus: when stdout is a terminal, the newline also causes buffered text to be flushed, so your message appears immediately.

The Tab Character and Tab Stops

A tab does not insert a fixed number of spaces. It moves to the next tab stop, and by default terminals place a stop every eight columns. That is why tabs make quick, aligned tables. Save this as ep_tab_table.c:

#include <stdio.h>

int main(void)
{
    printf("Pin\tMode\tState\n");
    printf("PA5\tOutput\tHigh\n");
    printf("PC13\tInput\tLow\n");
    return 0;
}

gcc -Wall -Wextra -std=c11 -o ep_tab_table ep_tab_table.c
./ep_tab_table

Expected output (tab stops every 8 columns):

Pin     Mode    State
PA5     Output  High
PC13    Input   Low

To see that a tab is a single byte and not spaces, pipe the output through od -c, which prints each byte by name:

./ep_tab_table | od -c | head -3

0000000   P   i   n  \t   M   o   d   e  \t   S   t   a   t   e  \n   P
0000020   A   5  \t   O   u   t   p   u   t  \t   H   i   g   h  \n   P
0000040   C   1   3  \t   I   n   p   u   t  \t   L   o   w  \n

Cursor Control With C Escape Sequences

The next group of C escape sequences moves the cursor instead of printing something visible. These are the ones that surprise students, because the final screen shows less than what was sent. Save this as ep_cursor_moves.c:

#include <stdio.h>

int main(void)
{
    printf("ABC\b\bX\n");
    printf("Loading...\rDone!     \n");
    printf("OK\r\n");
    return 0;
}

gcc -Wall -Wextra -std=c11 -o ep_cursor_moves ep_cursor_moves.c
./ep_cursor_moves | cat -v

The cat -v command makes control characters visible, which is the honest view of what the program wrote:

ABC^H^HX
Loading...^MDone!
OK^M

Here ^H is backspace and ^M is carriage return. If you run the program directly in a terminal instead, you see the effect of those controls:

AXC
Done!
OK

Carriage Return for Progress Messages

The carriage return puts the cursor back at column 0 without going down a line, so the next text overwrites the old. That is the trick behind single-line progress indicators. In our sample, Loading... is overwritten by Done!, and the trailing spaces are needed to wipe the leftover dots because the new text is shorter than the old.

Alert, Vertical Tab and Form Feed

Let us look at the remaining three with a short program, ep_beep.c:

#include <stdio.h>

int main(void)
{
    printf("Alert!\a\n");
    printf("Col1\vCol2\fCol3\n");
    return 0;
}

gcc -Wall -Wextra -std=c11 -o ep_beep ep_beep.c
./ep_beep | od -c

0000000   A   l   e   r   t   !  \a  \n   C   o   l   1  \v   C   o   l
0000020   2  \f   C   o   l   3  \n
0000027

The bytes are exactly what you wrote: 7 for the alert, 11 for the vertical tab and 12 for the form feed. What they do depends entirely on the receiving device. Many terminal emulators mute the bell. A vertical tab and form feed were designed for printers, and on a typical modern terminal they only move the cursor down without returning to the left edge, which makes the next text appear to step to the right. Treat them as rarely useful in everyday code.

Printing Quotes and Backslashes With Escape Sequences

A double quote ends a string literal, and a backslash starts an escape. So how do you print either one? You escape them. Save this as ep_quotes.c:

#include <stdio.h>

int main(void)
{
    printf("Log says: \"Sensor ready\"\n");
    printf("Path: C:\\embedded\\logs\n");
    printf("Apostrophe: it\'s fine, and so is it's\n");
    printf("Chars: %c %c %c\n", '\'', '"', '\\');
    printf("Hex escape: \x48\x69\n");
    printf("Octal escape: \110\151\n");
    return 0;
}

gcc -Wall -Wextra -std=c11 -o ep_quotes ep_quotes.c
./ep_quotes

Expected output:

Log says: "Sensor ready"
Path: C:\embedded\logs
Apostrophe: it's fine, and so is it's
Chars: ' " \
Hex escape: Hi
Octal escape: Hi

A few points are worth noticing. Inside a string you do not have to escape an apostrophe, but it is allowed. Inside a character literal the situation flips: you must write '\'' for the apostrophe, while '"' needs no escape. The last two lines show that any character can be written by its code: \x48\x69 is hexadecimal for H and i, and \110\151 is octal for the same two letters. This is handy for non-printable bytes in protocols, such as writing an ESC character as \x1b.

Predict the Output (Try Before You Click)

printf("One\nTwo\tThree\n");

One
Two     Three

printf("12345\rAB\n");

AB345

printf("Say \"%s\" to the \\ team\n", "hi");

Say "hi" to the \ team

printf("AB\0CD\n");

AB

Escape Sequences in Embedded Serial Output

Here is something that bites almost every newcomer to microcontrollers. On Linux, a newline moves down a line and returns to the left edge, so \n alone is enough. A raw serial terminal program often does not add that return for you. If your firmware sends only \n, the text can step across the screen like a staircase. The usual fix is to send \r\n, the traditional line ending of serial consoles.

Common C Escape Sequence Mistakes

• Using a forward slash: "/n" prints a slash and the letter n. The newline needs a backslash.
• A single backslash in a path: "C:\new" contains a newline, not a folder called new. Double every backslash.
• Greedy hex escapes: \x consumes as many hexadecimal digits as it can, so "\x41B" is one oversized value, not A followed by B. Compilers warn or reject it. Split the string, for example "\x41" "B".
• Forgetting the trailing newline: the next program output or shell prompt gets glued onto your last line.
• Expecting \a to beep everywhere: many terminals and all headless systems stay silent.

Best Practices, Performance and Security

Best Practices

• Use od -c or cat -v whenever output looks wrong. It shows the true bytes.
• Prefer \n in portable code and add \r only where the target device needs it.
• Avoid \v and \f in normal logging.
• Write raw bytes in protocols with explicit hex escapes and add a comment.

Performance Considerations

Escape sequences cost nothing at run time because the compiler resolves them while compiling. The only real cost is the extra byte on the wire. On a slow UART at 9600 baud, the additional \r in every line does add a little transmission time, so keep log lines short.

Security Considerations

Control bytes from C escape sequences in logs can be abused. A user-supplied string containing \r or terminal escape codes can overwrite earlier log text on a screen and hide activity. When you print untrusted input, sanitize or replace non-printable characters, and remember to print it with printf("%s", text) rather than using it as the format string.

Quick Quiz

Interview Questions on Escape Sequences

1. Who processes \n, the compiler or printf? The compiler converts it into a single byte; printf just passes it along.
2. What is the difference between \r and \n? Carriage return goes to the start of the current line; newline moves to the next line.
3. How do you print a double quote inside a string? Use \".
4. What does \0 do inside a string literal? It terminates the string for functions such as printf.
5. How can you inspect raw output bytes? Pipe the output through od -c or cat -v.
6. Why can a Windows path in a C string break? Single backslashes start escape sequences, so each must be doubled.

Summary and Key Takeaways

• An escape sequence is a backslash pair that the compiler turns into one special byte.
• Percent signs are handled by printf at run time; backslashes by the compiler at build time.
• Among C escape sequences, \n, \t, \r and \b are the everyday workhorses.
• \a, \v and \f send valid bytes, but the effect depends on the device.
• Escape quotes and backslashes with a preceding backslash, and use hex or octal escapes for arbitrary bytes.
• Serial consoles often need \r\n.
• od -c and cat -v reveal what a program truly printed.

Conclusion

You have now seen that C escape sequences are small but powerful tools: they shape the layout of every message your embedded code or driver prints. Together with format specifiers from the previous lecture, you can build clean, readable output for terminals, serial consoles and kernel logs. This knowledge is a stepping stone in the free embedded linux course and the free linux kernel development course, where well-formed log messages save hours of debugging. Next, we move on to formatted input and output, where you will control field width and alignment. Until then, experiment with the programs above and inspect their bytes with od -c.

Frequently Asked Questions