Introduction CompE160 to Programming
Marino
Day 22
1. The char data type
References
Deitel Chapter 8 and Appendix B.
AsciiCode.doc in folder Misc
Google Ascii Code
The data type char is used to represent characters, including both printing
characters (i.e., letters, numerals, punctuation marks, and a few special characters) and
various control characters (e.g., space, horizontal tab, vertical tab, and others).
The most widely used code for representing characters for many years has been
the American Standard Code for Information Interchange (Ascii, pronounced ask-ee).
See the document ASCII Code.doc in directory Misc for a definition of the Ascii
code. Appendix B of Deitel also defines the code, but Deitels table is a bit harder to
interpret.
The length of the char data type for our C compiler is one byte. Most C
compilers, including ours, use the first 128 byte values (i.e., the bytes beginning with bit
0) to represent characters using the Ascii code. The remaining 128 byte values (i.e., the
bytes beginning with 1) can be used to represent characters not represented by the Ascii
code, for example characters in other alphabets, math symbols, etc.. We will confine our
discussion to Ascii characters.
A few characteristics of the Ascii code that are useful for C-programmers to
recognize are the following:
The capital letters are sequential starting with decimal 65 (i.e., A is 65, B
is 66, etc.).
The lowercase letters are sequential, starting with 97 for letter a.
The decimal digits are sequential starting with 48 for character 0.
The space character is 32.
The horizontal tab stop character is 09.
The newline character may be represented by either 00001101 (carriage
return) or 00001010 (line feed). Which one is used depends upon the
compiler (see item 3 below).
2. Hexadecimal and Octal Representation of Binary Words
Octal notation is a shorthand notation for representing binary words. The bits of
a binary word are separated into groups of 3 bits, starting from the right. Each group of
3 bits is represented by a single decimal digit: 0 represents 000; 1 represents 001; 2
represents 010; 7 represents 111. For example, the binary word 11101110 is
represented in octal notation as 356.
Hexadecimal notation is the same as octal notation, except that the binary word
is separated into groups of 4 bits each. Since there are 16 different 4-bit words and only
10 decimal digits, we need 6 additional symbols to represent words 1010, 1011, 1111.
The first 6 letters of the alphabet are used for this purpose: A represents 1010; B
1
CompE160 Introduction to Programming
Marino
represents 1011; F represents 1111. For example, the word 11000101 is represented
in hexadecimal notation as C5.
Octal and hexadecimal notation are normally used simply as shorthand
representations of binary words. The words themselves may represent any sort of
information (e.g., integer values, characters, floating point values, colors, etc.). However,
octal notation may also be thought of as the base-8 representation of an integer value.
For example, the octal word 273 may be thought of as representing the integer 2*82 +
7*81 + 3*80 = 2*64 + 7*8 + 3*1 = 187. Similarly, hexadecimal notation can be thought
of as the base-16 representation of an integer value. For example, the hexadecimal word
3CE may be thought of as representing the integer value 3*162 + 12*161 + 14*160 =
3*256 + 12*16 + 14*1 = 974.
The C language allows hexadecimal notation to be used to represent integer
values. To indicate that an integer constant is being specified using hexadecimal
notation, precede the hex characters with 0x. For example, if x is an integer variable, the
statement x = 0x3CE; assigns the decimal value 974 to variable x.
3. Representing Character Values in a Program
In a C program, character values (character constants) are represented in single
quotes. For example, 'A' represents the byte 01000001. Notice that the letter A by
itself (i.e., without the enclosing quotes) cannot be used to represent the Ascii character
value for letter A because the letter A by itself would be interpreted by the compiler as
the name of a variable.
A few non-printing character values are represented by a "escape sequences".
Some of these we have already been using in strings. The most important of these are
'\n' for newline; '\t' for horizontal tab; '\b' for 00001000 (backspace); and '\a'
for 00000111 (bell or beep a for audible). For other special characters that are
represented by escape sequences, see Deitel, Section 9.10.
Any character value can be represented by an escape sequence that specifies the
Ascii byte in octal notation. For example, '\014' represents 00001100 (the formfeed
character, ff), and '\101' represents 01000001 (character A). C also allows hexadecimal
representation of characters in escape sequences. For example, \x41 represents
01000001 (capital A). Octal notation was widely used when C was first developed, but
hexadecimal notation is more commonly used today.
4. char Variables
Variables of type char are declared and initialized in the usual way. For example,
the declaration c1, statement
char c2 ='A';
allocates memory for two char variables named c1 and c2 (one byte each), and initializes
variable c2 to 01000001.
C allows the arithmetic operators (+, -, *, /, and %) and the relational
operators (<, <=, >, >=, ==, and !=) to be used with the char data type.
Hence it is possible to use a char variable as a one-byte integer variable. In fact, a char
variable may be declared as either signed (Two's Complement code range -128 through
+127) or unsigned (straight Base 2 code range 0 through 255). Which one is the default
when a variable is simply declared char depends on the compiler. To determine the
2
CompE160 Introduction to Programming
Marino
default type for your compiler, execute the statements:
char c = '\777';
printf("c = %d\n", c);
If the output is "c = 255", the data type char is unsigned char; if the output is "c = -1", the
data type char is signed char.
5. Using Arithmetic with char Variables
Arithmetic operators are useful for processing characters. For example, if a char
variable c represents an uppercase letter, it may be converted to lowercase by executing
the statement
c = c + 32;
since the Ascii code for each lowercase letter is 32 greater than the Ascii code for the
uppercase version (e.g., to convert A to a, add 32: 65 + 32 = 97). Equivalently (and
better),
c = c + ('a' 'A');
As another example, suppose that c is a char variable and x is an int variable. If c
represents a decimal digit ('0' through '9'), then the following statement will assign to x
the numeric value of the digit:
x = c '0';
6. Library Functions for Processing Characters
The C runtime library provides a collection of functions for processing character
data. These functions are in the sub-library ctype (header file ctype.h). The ctype
functions are all simple, and have names that suggest their purpose (e.g., toupper converts
lowercase letters to uppercase; isdigit returns true if a character is a decimal digit and
false otherwise; isxdigit returns true if a character is a hexadecimal digit, false otherwise).
The ctype functions all have a single parameter variable of type int. This seems
odd, since the input information is normally a character, not an int. However, C requires
that the int data type be at least as long as the char data type, so a char variable can be
specified as the argument in a call to a ctype function. It will automatically be converted
to an int without loss of information.
Exercises
1. Write a program that prints out a few characters using the hexadecimal escape
sequence notation to represent the characters. Include control characters as well as
printing characters from the Ascii table. To see the effect of some of the special
characters, try embedding the control characters in a sequence of normal printing
characters. For example, try the statement
printf("%c%c%c%c%c\n", '\x41', '\x42', '\x08', '\x43', '\x44' );
Refer to the Ascii table to explain the output.
Aside. Octal notation is not often used today. But you may occasionally see it in older
programs. The above printf statement would be written using octal escape sequences
instead of hexadecimal as follows:
printf("%c%c%c%c%c\n", '\101', '\102', '\010', '\103', '\104' );
Execute this statement to verify that this is so.
3
CompE160 Introduction to Programming
Marino
2. The CarriageReturn and LineFeed characters ('\x0D' and '\x0A') are often
troublesome, because not all systems handle them the same way. Experiment to see how
your system handles these characters. For example, try the statements
printf("%c%c%c%c%c\n\n",
printf("******\n");
printf("%c%c%c%c%c\n\n",
printf("******\n");
printf("%c%c%c%c%c\n\n",
printf("******\n");
printf("%c%c%c%c%c\n\n",
printf("******\n");
printf("%c%c%c%c%c\n\n",
'\x41', '\x42', '\x0A', '\x43', '\x44' );
'\x41', '\x42', '\x0D', '\x43', '\x44' );
'\x41', '\x0A', '\x0D', '\x43', '\x44' );
'\x41', '\x0D', '\x0A', '\x43', '\x44' );
'\x41', '\x0D', '\x42', '\x0A', '\x43' );
3. The newline character \n represents the control operation go to the beginning of
the next line. But the operation of going to the next line actually is represented by a
sequence of two Ascii characters: LineFeed \0A and CarriageReturn \0D . The
way \n is represented in memory may vary from one system to another. It might be
represented by \0A or by \0D , or by both \0A and \0D . Write a program
that determines how \n is represented on your system.
4. Write a program that prompts the user to enter an integer between 1 and 117 and then
prints the characters associated with that integer and the next 9 consecutive integer
values, all on the same line. Explain the output that is produced by consulting an Ascii
table
5. Try running the program of the previous exercise and entering larger integers, for
example, try entering 321 or 577. Can you explain the output that is produced?
6. Write your own versions of the library functions isdigit, isalnum,
isxdigit, toupper and tolower.
4