Storing Characters

Section 2.13 Storing Characters

Almost all programs perform a great deal of text string manipulation. Text strings are made up of arrays of characters. The first program you wrote was probably a “Hello world” program. If you wrote it in C, you used a statement like:

printf("Hello world\n");

🔗

or in C++:

cout << "Hello world" << endl;

🔗

When translating either of these statements into machine code, the compiler must do two things:

store each of the characters in a location in memory where the control unit can access them, and
generate the machine instructions to write the characters on the screen.

🔗

We start by considering how a single character is stored in memory. There are many codes for representing characters, but the most common one is the American Standard Code for Information Interchange (ASCII—pronounced “ask' e”). It uses seven bits to represent each character. Table 2.13.1 shows the bit patterns for each character in hexadecimal. If you are at your computer, you can generate this table by typing the command man ascii.

🔗

Table 2.13.1. ASCII code for representing characters. The bit patterns (bit pat.) are shown in hexadecimal.

bit		bit		bit		bit
pat.	char	pat.	char	pat.	char	pat.	char
$00$	`NUL` (Null)	$20$	`(space)`	$40$	`@`	$60$	`
$01$	`SOH` (Start of Heading)	$21$	`!`	$41$	`A`	$61$	`a`
$02$	`STX` (Start of Text)	$22$	`"`	$42$	`B`	$62$	`b`
$03$	`ETX` (End of Text)	$23$	`#`	$43$	`C`	$63$	`c`
$04$	`EOT` (End of Transmit)	$24$	`$`	$44$	`D`	$64$	`d`
$05$	`ENQ` (Enquiry)	$25$	`%`	$45$	`E`	$65$	`e`
$06$	`ACK` (Acknowledge)	$26$	`&`	$46$	`F`	$66$	`f`
$07$	`BEL` (Bell)	$27$	`'`	$47$	`G`	$67$	`g`
$08$	`BS` (Backspace)	$28$	`(`	$48$	`H`	$68$	`h`
$09$	`HT` (Horizontal Tab)	$29$	`)`	$49$	`I`	$69$	`i`
$0 a$	`LF` (Line Feed)	$2 a$	`*`	$4 a$	`J`	$6 a$	`j`
$0 b$	`VT` (Vertical Tab)	$2 b$	`+`	$4 b$	`K`	$6 b$	`k`
$0 c$	`FF` (Form Feed)	$2 c$	`,`	$4 c$	`L`	$6 c$	`l`
$0 d$	`CR` (Carriage Return)	$2 d$	`-`	$4 d$	`M`	$6 d$	`m`
$0 e$	`SO` (Shift Out)	$2 e$	`.`	$4 e$	`N`	$6 e$	`n`
$0 f$	`SI` (Shift In)	$2 f$	`/`	$4 f$	`O`	$6 f$	`o`
$10$	`DLE` (Data-Link Escape)	$30$	`0`	$50$	`P`	$70$	`p`
$11$	`DC1` (Device Control 1)	$31$	`1`	$51$	`Q`	$71$	`q`
$12$	`DC2` (Device Control 2)	$32$	`2`	$52$	`R`	$72$	`r`
$13$	`DC3` (Device Control 3)	$33$	`3`	$53$	`S`	$73$	`s`
$14$	`DC4` (Device Control 4)	$34$	`4`	$54$	`T`	$74$	`t`
$15$	`NAK` (Negative ACK)	$35$	`5`	$55$	`U`	$75$	`u`
$16$	`SYN` (Synchronous idle)	$36$	`6`	$56$	`V`	$76$	`v`
$17$	`ETB` (End of Trans. Block)	$37$	`7`	$57$	`W`	$77$	`w`
$18$	`CAN` (Cancel)	$38$	`8`	$58$	`X`	$78$	`x`
$19$	`EM` (End of Medium)	$39$	`9`	$59$	`Y`	$79$	`y`
$1 a$	`SUB` (Substitute)	$3 a$	`:`	$5 a$	`Z`	$7 a$	`z`
$1 b$	`ESC` (Escape)	$3 b$	`;`	$5 b$	`[`	$7 b$	`{`
$1 c$	`FS` (File Separator)	$3 c$	`<`	$5 c$	`\`	$7 c$	`\|`
$1 d$	`GS` (Group Separator)	$3 d$	`=`	$5 d$	`]`	$7 d$	`}`
$1 e$	`RS` (Record Separator)	$3 e$	`>`	$5 e$	`^`	$7 e$	`~`
$1 f$	`US` (Unit Separator)	$3 f$	`?`	$5 f$	`_`	$7 f$	`DEL`

🔗

This is not the sort of table that you would memorize. However, you should become familiar with some of its general characteristics. In particular, notice that the numerical characters, 0–9, are in a contiguous sequence in the code,

30

–

39 .

The same is true of the lower case alphabetic characters, a–z, and of the upper case characters, A–Z. Notice that the lower case alphabetic characters are numerically higher than the upper case.

🔗

The codes in the left-hand column of Table 2.13.1,

00

–

1 f,

define control characters. The ASCII code was developed in the 1960s for transmitting data from a sender to a receiver. If you read some of names of the control characters, you can imagine how they could be used to control the “dialog” between the sender and receiver. They can be generated on a keyboard by holding the control key down while pressing an alphabetic key. For example, ctrl-d generates an EOT (End of Transmission) character.

🔗

ASCII codes are usually stored in the rightmost seven bits of an eight-bit byte. The eighth bit (the highest-order bit) is called the parity bit. It can be used for error detection in the following way. The sender and receiver would agree ahead of time whether to use even parity or odd parity. Even parity means that an even number of ones is always transmitted in each character; odd parity means that an odd number of ones is transmitted. Before transmitting a character in the ASCII code, the sender would adjust the eighth bit such that the total number of ones matched the even or odd agreement. When the code was received, the receiver would count the ones in each eight-bit byte. If the sum did not match the agreement, the receiver knew that one of the bits in the byte had been received incorrectly. Of course, if two bits had been incorrectly received, the error would pass undetected, but the chances of this double error are remarkably small. Modern communication systems are much more reliable, and parity is seldom used when sending individual bytes.

🔗

In some environments the high-order bit is used to provide a code for special characters. A little thought will show you that even all eight bits will not support all languages, e.g., Greek, Russian, Chinese. The Unicode character standard was first introduced in 1987 and has evolved over the years. It includes additional bytes so it can handle other alphabets. Unicode is backwards compatible with ASCII. We will only use ASCII in this book.

🔗

A computer system that uses an ASCII video system can be programmed to send a byte to the screen. The video system interprets the bit pattern as an ASCII code (from Table 2.13.1) and displays the corresponding character on the screen.

🔗

Getting back to the text string, "Hello world\n", the compiler would store this as a constant array of characters. There needs to be a way to specify the length of this array. In a C-style string this is accomplished by using the sentinel character NUL at the end of the string. So the compiler must allocate thirteen bytes for this string. An example of how this string is stored in memory is shown in Figure 2.13.2. Notice that C uses the LF character as a single newline character even though the C syntax requires that the programmer write two characters, “\n”. The area of memory shown includes the three bytes immediately following the text string.

🔗

Table 2.13.2. A text string stored in memory by a C compiler, including three “garbage” bytes after the string. Values are shown in hexadecimal. A different compilation may place the string in a different memory location.

Address	Contents
$4004 a 1 :$	$48$
$4004 a 2 :$	$65$
$4004 a 3 :$	$6 c$
$4004 a 4 :$	$6 c$
$4004 a 5 :$	$6 f$
$4004 a 6 :$	$20$
$4004 a 7 :$	$77$
$4004 a 8 :$	$6 f$
$4004 a 9 :$	$72$
$4004 aa :$	$6 c$
$4004 ab :$	$64$
$4004 ac :$	$0 a$
$4004 ad :$	$00$
$4004 ae :$	$25$
$4004 af :$	$73$
$4004 b 0 :$	$00$

🔗

In Pascal the length of the string is specified by the first byte in the string. It is taken to be an 8-bit unsigned integer. So C-style strings are typically processed by sentinel-controlled loops, and count-controlled string processing loops are more common in Pascal. The C++ string class has additional features, but the actual text string is stored as a C-style text string within the C++ string instance.