The newline Character - and other vagaries!

One special problem in dealing with characters is how to represent the idea of a "line break" or a "new line". In the ASCII character set there are actually two separate numeric codes associated with the idea of line breaking - one called "carriage return" the other called "line feed". The terminology goes back to mechanical typewriters and teletypes, where moving on to a new line required two separate actions: the "carriage" carrying the roller and paper had to be moved back to the extreme right (so that the left hand edge of the paper was relocated under the printing position) and the paper had to be "fed" through the roller by the correct amount for a new line. Of course, these quaint historical origins have rather little to do with the operation of modern computer displays; but the distinction between moving the print position (the cursor) down a line, and moving it back to the left hand margin still exists, and so the distinct functions of the two ASCII control codes still apply. Nonetheless, it is conventional in C programming to have a single control code which is denoted by the sequence \n and which has the effect of both moving down a line, and moving back to the left hand margin. This special character is called the newline character.

Why cannot a newline simply be represented in the C file by, literally, inserting a new line? Why do we need this special sequence \n? The basic answer is that line breaks are used in a C program to try to lay it out in a legible manner; and that if we put in line breaks in the C file where what we really want is to have the program emit a line break at run time, then this will disrupt and interfere with the formatting of the C program. In fact, within C string constants, which is where line breaks are usually desired, it is illegal to insert a literal line break, and a compiler error would be generated. So it is necessary to invent some kind of more or less artificial way of indicating the idea of a line break, or the "newline" character within a C string, and \n is the way it is done. Note that when you write a statement like:

    printf("\n");

then the string which is actually stored internally in the computer at run time (and passed as an argument to printf()) contains just one character - the ASCII newline character, and not the two separate ASCII characters backslash and the letter n. In turn, what the printf() function actually "sends" to the screen is not the two separate characters \ and n, but rather the single ASCII newline character.

The sequence \n is called an "escape" sequence: the idea is that the character n is "escaping" from its normal interpretation, and is, instead, being given a special interpretation. Its a "sequence" because the n must be preceded by the special "escape" character, which, in this case, is the backslash character, \ . The use of an escape sequence to represent a special ASCII character (such as newline) introduces a difficulty of its own: what if we want to actually put the backslash character itself into a string? How can we prevent it being interpreted as an "escape" character? Well, the answer is obvious enough: if we want to incorporate, literally, the backslash character \ into a C string, we simply escape this escape character itself: i.e., we write \\ . Thus to print the backslash character using printf() we would write:

    printf("\\");

As well as the newline character, denoted \n there are a variety of other special ASCII characters which can be represented in C by escape sequences. Try out these sequences for yourself, and try to establish their effect: \r, \b, \t.