Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix A: Computer Arithmetic

I have deliberately kept discussion of number bases and arithmetic to a minimum in the chapters of this book. However, it’s important to have some understanding of this, so I’m summarizing the subject in this appendix. If you feel confident in your math skills, this review will be old hat for you. If you think the math parts are going to be tough, then this section should show you how easy it really is.

Binary Numbers

First, let’s consider exactly what you intend when you write a common, everyday decimal number , such as 324 or 911. Obviously, what you mean is “300 and 24” or “900 and 11.” These are a shorthand way of saying “300” plus “two 10s” plus “4” and “900” plus “one 10” plus “1.” Put more numerically and more precisely, you really mean

324 is 3 × 10² + 2 × 10¹ + 4 × 10⁰, which is 3 × 10 × 10 + 2 × 10 + 4
911 is 9 × 10² + 1 × 10¹ + 1 × 10⁰, which is 9 × 10 × 10 + 1 × 10 + 1

We call this decimal notation because it’s built around powers of 10. (This is derived from the Latin word decimal, meaning “of tithes,” which was a tax of 10 percent. Ah, those were the days!) We also say that we are representing numbers to base 10 here because each digit position is a power of 10.

Representing numbers in this way is very handy for people with ten fingers and ten toes, or indeed ten of any kind of appendage. However, your PC is rather less handy, being built mainly of switches that are either on or off. It’s okay for counting up to two, but not spectacular at counting to ten. I’m sure you’re aware that this is the primary reason why your computer represents numbers using base 2 rather than base 10. Representing numbers using base 2 is called the binary system of counting. With numbers expressed using base 10, digits can be from zero to nine inclusive. In general, if you are representing numbers in an arbitrary base, n, the digit in each position in a number can be from 0 to n-1. Thus, with binary numbers, digits can only be zero or one, which is ideal when you only have on and off switches to represent them. In an exact analogy to the system of counting in base 10, the binary number 1101, for example, breaks down like this:

1 × 2³ + 1 × 2² + 0 × 2¹ + 1 × 2⁰, which is 1 × 2 × 2 × 2 + 1 × 2 × 2 + 0 × 2 + 1

This amounts to 13 in the decimal system. In Table A-1, you can see the decimal equivalents of all the possible numbers you can represent using eight binary digits (a binary digit is more commonly known as a bit).

Table A-1.

Decimal Equivalents of 8-Bit Binary Values

Binary	Decimal	Binary	Decimal
0000 0000	0	1000 0000	128
0000 0001	1	1000 0001	129
0000 0010	2	1000 0010	130
. . .	. . .	. . .	. . .
0001 0000	16	1001 0000	144
0001 0001	17	1001 0001	145
. . .	. . .	. . .	. . .
0111 1100	124	1111 1100	252
0111 1101	125	1111 1101	253
0111 1110	126	1111 1110	254
0111 1111	127	1111 1111	255

Notice that using the first 7 bits, you can represent numbers from 0 to 127, which is a total of 128 numbers, and that using all 8 bits, you get 256 or 2⁸ numbers. In general, if you have n bits available, you can represent 2ⁿ integers, with values from 0 to 2ⁿ–1.

Adding binary numbers inside your computer is a piece of cake, because the “carry” from adding corresponding digits can only be zero or one. This means that very simple circuitry can handle the process. Figure A-1 shows how the addition of two 8-bit binary values would work.

../images/311070_6_En_BookBackmatter_Fig1_HTML.png — Figure A-1.
Adding binary values

The addition operation starts with adding the rightmost bits in the numbers. Figure A-1 shows that there is a “carry” of 1 to the next bit position for each of the first six bit positions. This is because each digit can only be zero or one. When you add 1 + 1, the result cannot be stored in the current bit position and is equivalent to one in the next bit position to the left.

Hexadecimal Numbers

When you start dealing with larger binary numbers , a small problem arises when you want to write them down. Look at this one:

1111 0101 1011 1001 1110 0001

Binary notation here starts to be more than a little cumbersome for practical use, particularly when you consider that if you work out what this is in decimal, it’s only 16,103,905—a miserable eight decimal digits. You can sit more angels on the head of a pin than that! Clearly, you need a more economical way of writing this, but decimal isn’t always appropriate. Sometimes you might need to be able to specify that the 10th and 24th bits from the right are set to one, but without the overhead of writing out all the bits in binary notation. To figure out the decimal integer required to do this sort of thing is hard work, and there’s a good chance you’ll get it wrong anyway. A much easier solution is to use hexadecimal notation, in which the numbers are represented using base 16.

Arithmetic to base 16 is a much more convenient option, and it fits rather well with binary. Each hexadecimal digit can have values from 0 to 15, and the digits from 10 to 15 are represented by the letters A–F (or a–f), as shown in Table A-2. Values from 0 to 15 happen to correspond nicely with the range of values that four binary digits can represent.

Table A-2.

Hexadecimal Digits and Their Values in Decimal and Binary

Hexadecimal	Decimal	Binary
0	0	0000
1	1	0001
2	2	0010
3	3	0011
4	4	0100
5	5	0101
6	6	0110
7	7	0111
8	8	1000
9	9	1001
A	10	1010
B	11	1011
C	12	1100
D	13	1101
E	14	1110
F	15	1111

Because a hexadecimal digit corresponds to four binary digits, you can represent any large binary number as a hexadecimal number simply by taking groups of four binary digits, starting from the right, and writing the equivalent hexadecimal digit for each group. Look at the following binary number:

1111 0101 1011 1001 1110 0001

Taking each group of 4 bits in turn and replacing it with the corresponding hexadecimal digit from the table, this number expressed in hexadecimal notation will come out as follows:

F 5 B 9 E 1

You have six hexadecimal digits corresponding to the six groups of four binary digits. Just to prove that it all works out with no cheating, you can convert this number directly from hexadecimal to decimal by again using the analogy with the meaning of a decimal number. The value of this hexadecimal number therefore works out as follows.

F5B9E1 as a decimal value is given by

15 × 16⁵ + 5 × 16⁴ + 11 × 16³ + 9 × 16² + 14 × 16¹ + 1 × 16⁰

This turns out to be

15,728,640 + 327,680 + 45,056 + 2,304 + 224 + 1

Thankfully, this adds up to the same number you got when converting the equivalent binary number to a decimal value: 16,103,905.

The other very handy coincidence with hexadecimal numbers is that modern computers store integers in words that are even numbers of bytes, typically 2, 4, 8, or 16 bytes. A byte is 8 bits, which is exactly two hexadecimal digits, so any binary integer word in memory always corresponds to an exact number of hexadecimal digits.

Negative Binary Numbers

There’s another aspect to binary arithmetic that you need to understand: negative numbers. So far, you’ve assumed that everything is positive—the optimist’s view, if you will—and so the glass is still half full. But you can’t avoid the negative side of life—the pessimist’s perspective—that the glass is already half empty. How can a negative number be represented inside a computer? Well, you have only binary digits at your disposal, so the solution has to be to use at least one of those to indicate whether the number is negative or positive.

For numbers that you want to allow to have negative values (referred to as signed numbers ), you must first decide on a fixed length (in other words, the number of binary digits) and then designate the leftmost binary digit as a sign bit. You have to fix the length to avoid any confusion about which bit is the sign bit.

As you know, your computer’s memory consists of 8-bit bytes, so the binary numbers are going to be stored in some multiple (usually a power of 2) of 8 bits. Thus, you can have some numbers with 8 bits, some with 16 bits, and some with 32 bits or whatever. As long as you know what the length is in each case, you can find the sign bit—it’s just the leftmost bit. If the sign bit is zero, the number is positive, and if it’s one, the number is negative.

This seems to solve the problem, and in some computers it does. Each number consists of a sign bit that is zero for positive values and one for negative values, plus a given number of bits that specify the absolute value of the number—unsigned, in other words. Changing +6 to –6 then just involves flipping the sign bit from zero to one. Unfortunately, this representation carries a lot of overhead with it in terms of the complexity of the circuits that are needed to perform arithmetic. For this reason, most computers take a different approach. You can get the idea of how this approach works by considering how the computer would handle arithmetic with positive and negative values so that operations are as simple as possible.

Ideally, when two integers are added, you don’t want the computer to be searching about, checking whether either or both of the numbers are negative. You just want to use simple “add” circuitry regardless of the signs of the operands. The add operation will combine corresponding binary digits to produce the appropriate bit as a result, with a carry to the next digit along where this is necessary. If you add –8 in binary to +12, you would really like to get the answer +4 using the same circuitry that would apply if you were adding +3 and +8.

If you try this with the simplistic solution, which is just to set the sign bit of the positive value to one to make it negative, and then perform the arithmetic with conventional carries, it doesn’t quite work:

12 in binary is	0000 1100
–8 in binary (you suppose) is	1000 1000
If you now add these together, you get	1001 0100

This seems to be –20, which isn’t what you wanted at all. It’s definitely not +4, which you know is 0000 0100. “Ah,” I hear you say, “you can’t treat a sign just like another digit.” But that is just what you do want to do.

You can see how the computer would like to represent –8 by subtracting +12 from +4 and seeing what the result is:

+4 in binary is	0000 0100
+12 in binary is	0000 1100
Subtract the latter from the former and you get	1111 1000

For each digit from the fourth from the right onward, you had to “borrow” 1 to do the subtraction, just as you would when performing ordinary decimal arithmetic. This result is supposed to be –8, and even though it doesn’t look like it, that’s exactly what it is. Just try adding it to +12 or +15 in binary, and you’ll see that it works! Of course, if you want to produce –8, you can always do so by subtracting +8 from 0.

What exactly did you get when you subtracted 12 from 4 or +8 from 0, for that matter? It turns out that what you have here is called the two’s complement representation of a negative binary number, and you can produce this from any positive binary number by a simple procedure you can perform in your head. At this point, I need to ask a little faith on your part and avoid getting into explanations of why it works. I’ll just show you how the two’s complement form of a negative number can be constructed from a positive value, and you can prove to yourself that it does work. Let’s return to the previous example, in which you need the two’s complement binary representation for –8.

You start with +8 in binary:

0000 1000

You now “flip” each binary digit, changing 0s to 1s and vice versa:

1111 0111

This is called the one’s complement form, and if you now add 1 to this, you’ll get the two’s complement form:

1111 1000

This is exactly the same as the representation of –8 you got by subtracting +12 from +4. Just to make absolutely sure, let’s try the original sum of adding –8 to +12:

+12 in binary is 0000 1100
Your version of –8 is 1111 1000
If you add these together, you get 0000 0100

The answer is 4—magic. It works! The “carry” propagates through all the leftmost ones, setting them back to zero. One fell off the end, but you shouldn’t worry about that—it’s probably compensating for the one you borrowed from the end in the subtraction sum you did to get –8. In fact, what’s happening is that you’re implicitly assuming that the sign bit, one or zero, repeats forever to the left. Try a few examples of your own; you’ll find it always works, automatically. The really great thing about the two’s complement representation of negative numbers is that it makes arithmetic very easy (and fast) for your computer.

Big-Endian and Little-Endian Systems

As I have discussed, integers generally are stored in memory as binary values in a contiguous sequence of bytes, commonly groups of 2, 4, 8, or 16 bytes. The question of the sequence in which the bytes appear can be very important—it’s one of those things that doesn’t matter until it matters, and then it really matters.

Let’s consider the decimal value 262,657 stored as a 4-byte binary value. I chose this value because in binary it happens to be

0000 0000 0000 0100 0000 0010 0000 0001

So each byte has a pattern of bits that is easily distinguished from the others.

If you’re using a PC with an Intel processor, the number will be stored as follows:

Byte address:	00	01	02	03
Data bits:	0000 0001	0000 0010	0000 0100	0000 0000

As you can see, the most significant 8 bits of the value—the one that’s all zeros—are stored in the byte with the highest address (last, in other words), and the least significant 8 bits are stored in the byte with the lowest address, which is the leftmost byte. This arrangement is described as a little-endian system.

If you’re using a mainframe computer , a workstation, a Mac machine based on a Motorola processor (nevertheless, current Mac machines are Intel), or networking protocols (ICMP/TCP/UDP commonly uses big endian), the same data are likely to be arranged in memory like this:

Byte address:	00	01	02	03
Data bits:	0000 0000	0000 0100	0000 0010	0000 0001

Now the bytes are in reverse sequence with the most significant 8 bits stored in the leftmost byte, which is the one with the lowest address. This arrangement is described as a big-endian system.

Note

Regardless of whether the byte order is big endian or little endian, the bits within each byte are arranged with the most significant bit on the left and the least significant bit on the right.

This is all very interesting, you might say, but why should it matter? Most of the time, it doesn’t. More often than not, you can happily write your C program without knowing whether the computer on which the code will execute is big endian or little endian. It does matter, however, when you’re processing binary data that come from another machine. Binary data will be written to a file or transmitted over a network as a sequence of bytes. It’s up to you how you interpret these data. If the source of the data is a machine with a different endianness from the machine on which your code is running, you must reverse the order of the bytes in each binary value. If you don’t, you will have garbage.

For those who collect curious background information, the terms big endian and little endian are drawn from the book Gulliver’s Travels by Jonathan Swift. In the story, the emperor of Lilliput commanded all his subjects to always crack their eggs at the smaller end. This was a consequence of the emperor’s son having cut his finger following the traditional approach of cracking his egg at the big end. Ordinary, law-abiding Lilliputian subjects who cracked their eggs at the smaller end were described as Little Endians. The Big Endians were a rebellious group of traditionalists in the Lilliputian kingdom who insisted on continuing to crack their eggs at the big end. Many were put to death as a result.

Continuing with the number 262,657 about little- and big-endian representations, we can test it against the following code. As you can perceive, it examines the number itself. Besides, there is a simple integer (int e) to see the architecture endianness (depending on the order, it will return a one if it is little endian or a zero if it's big endian):

// Program a.1 Checking endianness

#include <stdio.h>

int main(void)

{

int n = 0x40201; // 0x40201 = 262657

char* p = (char*) &n;

int e = 0x1;

char *q = (char*)&e;

//4 bytes an integer:

for (int i = 0; i < 4; i++)

{

printf("memory address: %p: value: %d ", p, *p++);

}

if(q[0] == 1) // checking endianness

{

printf(" It's Little-Endian. ");

}

else

{

printf(" It's Big-Endian. ");

}

return 0;

}

Here’s an example of some output from this program on my machine:

memory address: 00000000002df785: value: 1

memory address: 00000000002df786: value: 2

memory address: 00000000002df787: value: 4

memory address: 00000000002df788: value: 0

It's Little-Endian..

Floating-Point Numbers

We often have to deal with very large numbers—the number of protons in the universe, for example—which need around 79 decimal digits. Clearly there are lots of situations in which you’ll need more than the ten decimal digits you get from a 4-byte binary number. Equally, there are lots of very small numbers, for example, the amount of time in minutes it takes the typical car salesperson to accept your generous offer on a 2001 Honda (which has covered only 480,000 miles…). A mechanism for handling both these kinds of numbers is, as you may have guessed, floating-point numbers .

A floating-point representation of a number in decimal notation is a decimal value, called the mantissa , which is greater than or equal to 0.0 and less than 1.0 with a fixed number of digits, with this value multiplied by a power of 10 to produce the actual value. This power of 10 is called the exponent . It’s easier to demonstrate this than to describe it, so let’s look at some examples. The number 365 in normal decimal notation could be written in floating-point form as follows:

0.3650000E03

The E stands for “exponent” and precedes the power of 10 that the 0.3650000 (the mantissa) part is multiplied by to get the required value. That is

0.3650000 × 10 × 10 × 10

This is clearly 365.

The mantissa in the number here has seven decimal digits. The number of digits of precision in a floating-point number will depend on how much memory it is allocated. A single-precision floating-point value occupies 4 bytes where the 32 bits are allocated like this:

bit 0: The sign bit
bits 1–8: The binary exponent
bits 9–31: The binary mantissa

Thus, a single-precision floating-point value will provide approximately seven decimal digits’ accuracy. I say “approximately” because a binary fraction with 23 bits doesn’t exactly correspond to a decimal fraction with seven decimal digits.

Note

To be more precise, the mantissa in a single-precision binary floating-point number is 24 bits because the leading bit in regular values is 1 and therefore implied. It's still approximately seven decimal digits though.

A double-precision binary floating-point value occupies 8 bytes with the exponent using 11 bits after the sign bit and the mantissa occupying the remaining 52 bits with an implied leading binary digit that is 1.

Now let’s look at a small number:

0.3650000E-04

This is evaluated as 0.365 × 10^-4, which is 0.0000365—exactly the time in minutes required by the car salesperson to accept your cash.

Suppose you have a large number such as 2,134,311,179. How does this look as a floating-point number? Well, it would look like this:

0.2134311E10

It’s not quite the same. You’ve lost three low-order digits, and you’ve approximated your original value as 2,134,311,000. This is a small price to pay for being able to handle such a vast range of numbers, typically from 10^–38 to 10⁺³⁸ either positive or negative, as well as having an extended representation that goes from a minute 10^–308 to a mighty 10⁺³⁰⁸. They’re called floating-point numbers for the fairly obvious reason that the decimal point “floats” and its position depends on the exponent value.

Aside from the fixed precision limitation in terms of accuracy, there’s another aspect of which you may need to be conscious. You need to take great care when adding or subtracting numbers of significantly different magnitudes. A simple example will demonstrate the problem. You can first consider adding 0.365E-3 to 0.365E+7. You can write this as a decimal sum:

0.000365 + 3,650,000.0

This produces this result:

3,650,000.000365

When converted back to a floating-point value with seven digits of precision, this becomes

0.3650000E+7

Adding 0.365E-3 to 0.365E+7 has had no effect whatsoever, so you might as well not have bothered. The problem lies directly with the fact that you carry only six or seven digits of precision. The digits of the larger number aren’t affected by any of the digits of the smaller number because they’re all farther to the right. Oddly enough, you must also take care when the numbers are nearly equal. If you compute the difference between such numbers, you may end up with a result that has only one or two digits of precision. It’s quite easy in such circumstances to end up computing with numbers that are totally garbage.

While floating-point numbers enable you to carry out calculations that would be impossible without them, you must always keep their limitations in mind if you want to be sure your results are valid. This means considering the range of values you are likely to be working with and their relative values.

Appendix B: ASCII Character Code Definitions

The first 32 American Standard Code for Information Interchange (ASCII) characters provide control functions for peripheral devices such as printers and do not have a specific printable representation. Many of these haven’t been referenced in this book but are included here for completeness. In Table B-1, only the first 128 characters are included. The remaining 128 characters include further special symbols and letters for national character sets.

Table B-1.

ASCII Character Code Values

Decimal	Hexadecimal	Character	Control
000	00		NUL: Null character
001	01		SOH: Start of Heading
002	02		STX: Start of Text
003	03		ETX: End of Text
004	04		EOT: End of Transmission
005	05		ENQ: Enquiry
006	06		ACK: Acknowledgement
007	07		BEL: (audible bell)
008	08		BS: Backspace
009	09		HT: Horizontal Tab
010	0A		LF: Line Feed
011	0B		VT: Vertical Tab
012	0C		FF: Form-Feed
013	0D		CR: Carriage Return
014	0E		SO: Shift Out/X-On
015	0F		SI: Shift In/X-Off
016	10		DLE: Data Line Escape
017	11		DC1: Device Control 1
018	12		DC2: Device Control 2
019	13		DC3: Device Control 3
020	14		DC4: Device Control 4
021	15		NAK: Negative Acknowledgment
022	16		SYN: Synchronous Idle
023	17		ETB: End of Transmission Block
024	18		CAN: Cancel
025	19		EM: End of Medium
026	1A		SUB: Substitute
027	1B		ESC: Escape
028	1C		FS: File Separator
029	1D		GS: Group Separator
030	1E		RS: Record Separator
031	1F		US: Unit Separator
032	20		Space
033	21	!	—
034	22	"	—
035	23	#	—
036	24	$	—
037	25	%	—
038	26	&	—
039	27	'	—
040	28	(	—
041	29	)	—
042	2A	*	—
043	2B	+	—
044	2C	,	—
045	2D	-	—
046	2E	.	—
047	2F	/	—
048	30	0	—
049	31	1	—
050	32	2	—
051	33	3	—
052	34	4	—
053	35	5	—
054	36	6	—
055	37	7	—
056	38	8	—
057	39	9	—
058	3A	:	—
059	3B	;	—
060	3C	<	—
061	3D	=	—
062	3E	>	—
063	3F	?	—
064	40	@	—
065	41	A	—
066	42	B	—
067	43	C	—
068	44	D	—
069	45	E	—
070	46	F	—
071	47	G	—
072	48	H	—
073	49	I	—
074	4A	J	—
075	4B	K	—
076	4C	L	—
077	4D	M	—
078	4E	N	—
079	4F	O	—
080	50	P	—
081	51	Q	—
082	52	R	—
083	53	S	—
084	54	T	—
085	55	U	—
086	56	V	—
087	57	W	—
088	58	X	—
089	59	Y	—
090	5A	Z	—
091	5B	[	—
092	5C		—
093	5D	]	—
094	5E	^	—
095	5F	_	—
096	60	`	—
097	61	a	—
098	62	b	—
099	63	c	—
100	64	d	—
101	65	e	—
102	66	f	—
103	67	g	—
104	68	h	—
105	69	i	—
106	6A	j	—
107	6B	k	—
108	6C	l	—
109	6D	m	—
110	6E	n	—
111	6F	o	—
112	70	p	—
113	71	q	—
114	72	r	—
115	73	s	—
116	74	t	—
117	75	u	—
118	76	v	—
119	77	w	—
120	78	x	—
121	79	y	—
122	7A	z	—
123	7B	{	—
124	7C	\|	—
125	7D	}	—
126	7E	~	—
127	7F		Delete

Appendix D: Input and Output Format Specifications

Output Format Specifications

There are 16 standard library functions for formatted output that have the following prototypes:

int printf(const char * restrict format, ...);

int printf_s(const char * restrict format, ...);

int sprintf(char * restrict str, const char* restrict format, ...);

int sprintf_s(char * restrict str, rsize_t n, const char* restrict format, ...);

int snprintf(char * restrict, size_t, const char * restrict, ...);

int snprintf_s(char * restrict str, rsize_t n, const char* restrict format, ...);

int fprintf(FILE * restrict stream, const char* restrict format, ...);

int fprintf_s(FILE * restrict stream, const char* restrict format, ...);

int vfprintf(FILE * restrict, const char * restrict, va_list);

int vsprintf(char * restrict, const char * restrict, va_list);

int vprintf(const char * restrict, va_list);

int vsnprintf(char * restrict, size_t, const char * restrict, va_list);

int vfprintf_s(FILE * restrict, const char * restrict, va_list);

int vprintf_s(const char * restrict, va_list);

int vsnprintf_s(char * restrict, rsize_t, const char * restrict, va_list);

int vsprintf_s(char * restrict, rsize_t, const char * restrict, va_list);

The functions with names ending in _s are optional and require that __STDC_WANT_LIB_EXT1__ be defined as 1. The ellipsis at the end of the parameter list indicates that there can be zero or more arguments supplied. These functions return the number of bytes written or a negative value if an error occurred. The format string can contain ordinary characters (including escape sequences) that are written to the output together with format specifications for outputting the values of succeeding arguments.

An output format specification always begins with a % character and has the following general form :

%[flags][width][.precision][size_flag]type

The items between square brackets are all optional, so the only mandatory bits are the % character at the beginning and the type specifier for the type of conversion to be used.

The possible choices for each of the optional parts are as follows:

[flags] are zero or more conversion flags that control how the output is presented. The flags you can use are as follows:
- +: Include the sign in the output, + or -. For example, %+d will output a decimal integer with the sign always included.
- space: Use space or - for the sign (i.e., a positive value is preceded by a space). This is useful for aligning output when there may be positive and negative values in a column of output. For example, % d will output a decimal integer with a space for the sign with positive values.
- -: Left justify the output in the field width with spaces padding to the right if necessary. For example, %-10d will output an integer as a decimal value left justified in a field width of ten characters. The %-+10d specification will output a decimal integer with the sign always appearing and left justified in a field width of ten characters.
- #: Prefix hexadecimal output values with 0x or 0X (corresponding to x and X conversion type specifications, respectively) and octal values with 0. Always include a decimal point in floating-point values. Do not remove trailing zeros for g and G specifications.
- 0: Use 0 as the pad character to the left in a right-justified numerical output value. For example, %012d will output a decimal integer right justified in a field width of 12 characters, padded to the left with zeros as necessary. If precision is specified for an integer output, the 0 flag is ignored.
[width] specifies the minimum field width for the output value. The width you specify will be exceeded if the value does not fit within the specified minimum width. For example, %15u outputs an unsigned integer value right justified in a field width of 15 characters padded to the left with spaces as necessary.
[.precision] specifies the number of places following the decimal point in the output for a floating-point value. For example, %15.6f outputs a floating-point value in a minimum field width of 15 characters with six places after the decimal point. For integer conversions, it specifies the minimum number of digits.
[size_flag] is a size specification for the value that modifies the meaning of the type specification. Possible size specifications are as follows:
- l (lowercase l) specifies that a d, i, u, o, x, or X conversion type applies to an argument of type long or unsigned long. When applied to a type n conversion, the argument is type long*. When applied to a type c conversion, the argument is type wint_t. When applied to a type s conversion, the argument is type wchar_t*.
- L specifies that a following floating-point conversion specifier applies to a long double argument.
- ll (two lowercase Ls) specifies that a d, i, u, o, x, or X conversion type applies to an argument of type long long or unsigned long long. When applied to a type n conversion, the argument is type long long*.
- h specifies that a d, i, u, o, x, or X conversion type applies to an argument of type short or unsigned short. When applied to a type n conversion, the argument is type short*.
- hh specifies that a d, i, u, o, x, or X conversion type applies to an argument of type signed char or unsigned char. When applied to a type n conversion, the argument is type signed char*.
- j specifies that a following d, i, u, o, x, or X conversion type applies to an argument of type intmax_t or uintmax_t. When applied to an n conversion, the argument is of type intmax_t*.
- z specifies that a following d, i, u, o, x, or X conversion type applies to an argument of type size_t. When applied to an n conversion, the argument is of type size_t*.
- t specifies that a following d, i, u, o, x, or X conversion type applies to an argument of type ptrdiff_t. When applied to an n conversion, the argument is of type ptrdiff_t*.
type is a character specifying the type of conversion to be applied to a value as output:
- d, i: The value is assumed to be of type int, and the output is as a signed decimal integer.
- u: The value is assumed to be of type unsigned int, and the output is as an unsigned decimal integer.
- o: The value is assumed to be of type unsigned int, and the output is as an unsigned octal value.
- x: or X The value is assumed to be of type unsigned int, and the output is as an unsigned hexadecimal value. The hexadecimal digits a–f are used if the lowercase type conversion specification is used and A–F otherwise.
- c: The value is assumed to be of type char, and the output is as a character.
- a or A: The value is assumed to be of type double, and the output is as a floating-point value in hexadecimal scientific notation (with an exponent). The exponent value in the output will be preceded by p when you use the lowercase type conversion and P otherwise. Uppercase hexadecimal digits are used for output with A and lowercase with a.
- e or E: The value is assumed to be of type double, and the output is as a floating-point value in decimal scientific notation (with an exponent). The exponent value in the output will be preceded by e when you use the lowercase type conversion and E otherwise.
- f or F: The value is assumed to be of type double, and the output is as a floating-point value in ordinary notation (without an exponent).
- g or G: The value is assumed to be of type double, and the output is as a floating-point value in ordinary notation (without an exponent) unless the exponent value is greater than the precision (default value 6) or is less than –4, in which case the output will be in scientific notation.
- s: The argument is assumed to be a null-terminated string of characters of type char, and characters are output until the null character is found or until the precision specification is reached if it is present. The optional precision specification represents the maximum number of characters that may be output.
- p: The argument is assumed to be a pointer, and because the output is an address, it will be a hexadecimal value.
- n: The argument is assumed to be a pointer of type int*, and the number of characters in the output so far is stored at the address pointed to by the argument. You cannot use this with the optional library functions for formatted output.
- %: No argument is expected, and the output is the % character.

Input Format Specifications

C supports a number of input specifications, which are described in this section. These apply to the input functions that have the following prototypes:

int scanf(const char * restrict format, ...);

int scanf_s(const char * restrict format, ...);

int vscanf(const char * restrict format, va_list arg);

int vscanf_s(const char * restrict format, va_list arg);

int sscanf(const char * restrict source, const char * restrict format, ...);

int sscanf_s(const char * restrict source, const char * restrict format, ...);

int vsscanf(const char * restrict source, const char * restrict format, va_list arg);

int vsscanf_s(const char * restrict source, const char * restrict format, va_list arg);

int fscanf(FILE * restrict stream, const char * restrict format, ...);

int fscanf_s(FILE * restrict stream, const char * restrict format, ...);

int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);

int vfscanf_s(FILE * restrict stream, const char * restrict format, va_list arg);

The first eight functions read from stdin, and the last four read from a stream. The functions with names ending in _s are optional safe bounds checking versions of standard functions and require that __STDC_WANT_LIB_EXT1__ be defined as 1. Each of these functions returns a count of the number of data items read by the operation. The ellipsis at the end of the parameter list indicates that there can be zero or more arguments here. Don’t forget single arguments corresponding to a format specification that follow the format string must always be pointers. It is a common error to use a variable that is not a pointer as an argument to one of these input functions. The secure functions require that two arguments are supplied for c, s, and [ type specifiers, in which case the first must be a pointer and the second must be a value of type size_t.

The format string controlling how the input is processed can contain spaces, other characters, and format specifications for data items, each format specification beginning with a % character.

A single whitespace character in the format string causes the function to ignore successive whitespace characters in the input. The first nonwhitespace character found will be interpreted as the first character of the next data item. When a newline character in the input follows a value that has been read (e.g., when you are reading a single character from the keyboard using the %c format specification), any newline, tab, or space character that is entered will be read as the input character. This will be particularly apparent when you are reading a single character repeatedly, where the newline from the Enter key press will be left in the buffer. If you want the function to ignore the whitespace in such situations, you can force the function to skip whitespace by including at least one whitespace character preceding the %c in the format string.

You can also include nonwhitespace characters in the input format string that are not part of a format specification. Any nonwhitespace character in the format string that is not part of a format specification must be matched by the same character in the input; otherwise, the input operation ends.

The format specification for an item of data is of the form:

%[*][width][size_flag]type

The items enclosed between square brackets are optional. The mandatory parts of the format specification are the % character marking the start of the format specification and the conversion type specification at the end. The choices for the optional parts are as follows:

[*] indicates that the input data item corresponding to this format specification should be scanned but not stored. For example, %*d will scan an integer value and discard it.
[width] specifies the maximum number of characters to be scanned for this input value. If a whitespace character is found before width characters have been scanned, then that is the end of the input for the current data item. For example, %2d reads up to two characters as an integer value. The width specification is useful for reading multiple inputs that are not separated by whitespace characters. You could read 12131415 and interpret it as the values 12, 13, 14, and 15 by using "%2d%2d%2d%2d" as the format string.
[size_flag] modifies the input type specified by the type part of the specification. Possible size_flag specifications are as follows:
- l (lowercase L) specifies that a d, i, u, o, x, X, or n conversion type applies to an argument of type long* or unsigned long*. When applied to a type a, A, e, E, f, F, g, or G conversion, the argument is type double*. When applied to a type c, s, or [ conversion, the argument is type wchar_t*.
- L specifies that a following floating-point conversion specifier applies to a long double* argument.
- ll (two lowercase Ls) specifies that a d, i, u, o, x, X, or n conversion type applies to an argument of type long long* or unsigned long long*.
- h specifies that a d, i, u, o, x, X, or n conversion type applies to an argument of type short* or unsigned short*.
- hh specifies that a d, i, u, o, x, X, or n conversion type applies to an argument of type signed char* or unsigned char*.
- j specifies that a following d, i, u, o, x, X, or n conversion type applies to an argument of type intmax_t* or uintmax_t*.
- z specifies that a following d, i, u, o, x, X, or n conversion type applies to an argument of type size_t*.
- t specifies that a following d, i, u, o, x, X, or n conversion type applies to an argument of type ptrdiff_t*.
type specifies the type of data conversion and can be any of the following:
- c reads a single character as type char.
- d or i reads successive decimal digits as a value of type int.
- u reads successive decimal digits as a value of type unsigned int.
- o reads successive octal digits as a value of type unsigned int.
- x or X reads successive hexadecimal digits as a value of type unsigned int.
- a, A, e, E, f, F, g, or G reads an optionally signed floating-point value as a value of type float.
- s reads successive characters until a whitespace is reached and stores the characters read in the buffer pointed to by the corresponding argument.
- p reads the input as a pointer value. The corresponding argument must be of type void**.
- % matches a single % character in the input that is not stored.
- n: No input is read, but the number of characters that have been read from the input source up to this point is stored in the corresponding argument, which should be of type int*.

To read a string that includes whitespace characters, you have the %[set_of_characters] form of specification available. This specification reads successive characters from the input source as long as they appear in the set you supply between the square brackets. Thus, the specification %[ abcdefghijklmnopqrstuvwxyz] will read any sequence of lowercase letters and spaces as a single string. A more useful variation on this is to precede the set of characters with a caret, ^, as in %[^set_of_characters], in which case the set_of_characters represents the characters that will be interpreted as ending the string input. For example, the specification %[^,!] will read a sequence of characters until either a comma or an exclamation point is found, which will end the string input.

Appendix E: Standard Library Header Files

The following table lists the standard header files that may be implemented by a compiler that conforms to the C11 language standard. Some of these are optional and so may not be provided by a conforming implementation.

Header file name

Contents

assert.h

Defines the assert and static_assert macros

complex.h

An optional header in the C11 standard. It defines functions and macros that support operations with complex numbers

ctype.h

Defines functions for classifying and mapping characters:

isalpha()	isalnum()	isupper()	islower()
isblank()	isspace()	iscntrl()	isdigit()
ispunct()	isgraph()	isprint()	isxdigit()
tolower()	toupper()

errno.h

Defines macros for the reporting of errors:

errno

EDOM

ERANGE

EILSEQ

fenv.h

Defines types, functions, and macros for setting up the floating-point environment

float.h

Defines macros that define limits and properties for floating-point values.

inttypes.h

Extends stdint.h to provide macros for format specifiers for input and output using fprintf() and fscanf(). Each macro expands to a string literal containing a format specifier. The header also contains functions for greatest-width integer types

iso646.h

Defines macros such as bitand, and, and bitor, or, that expand to tokens that represent logical operations such as &, &&, |, and ||. These are for use in circumstances where the bitwise and logical operators cannot otherwise be entered from the keyboard

limits.h

Defines macros that expand to values defining limits for the standard integer types

locale.h

Defines functions and macros to assist with formatting data such as monetary units for different countries

math.h

Defines functions for common mathematical operations

setjmp.h

Defines facilities that enable you to bypass the normal function call and return mechanism

signal.h

Defines facilities for dealing with conditions that arise during program execution, including error conditions

stdalign.h

Defines macros for determining and setting the alignment of variables in memory. Alignment can be important for the efficient execution of computationally intensive operations

stdarg.h

Defines facilities that enable a variable number of arguments to be passed to a function

stdatomic.h

An optional header that defines facilities for managing multithreaded program execution

stdbool.h

Defines the macros bool, true, and false: bool expands to _Bool, and true and false expand to 1 and 0, respectively. These provide more readable alternatives to the formal language representations that were chosen so as not to break existing code

stddef.h

Declares standard types size_t, max_align_t, ptrdiff_t, and wchar_t: size_t is an unsigned integer type that is the type for the value returned by the sizeof operator, max_align_t is a type whose alignment is as large as any other supported scalar type, wchar_t is an integer type that accommodates a complete set of character codes for any supported locale, and ptrdiff_t is a signed integer type that is the type for the value that results from subtracting one pointer from another. The header also defines the macros NULL and offsetof(type, member). NULL is a constant that corresponds to a pointer value that does not point to anything. And offsetof(type, member) expands to a value of size_t that is the offset in bytes of member in a type structure

stdint.h

Defines integer types with specified widths and macros, specifying the limits for these types

stdio.h

Defines macros and functions for input and output. Reading data from the keyboard and writing output to the command line require this header to be included

stdlib.h

Defines a large number of general-purpose functions and macros. It includes functions to convert strings to numerical values, the rand() function that generates pseudo-random numbers, functions for dynamically allocating and deallocating memory for your data, searching and sorting routines, integer arithmetic functions, and functions for converting multibyte and wide character strings

stdnoreturn.h

Defines the macro noreturn that expands to _Noreturn. Specifying a return type as _Noreturn indicates to the compiler that the function does not return a value. This allows the compiler to perform code optimization while taking this into account

string.h

Defines functions for processing strings

tgmath.h

A header that includes math.h and complex.h and defines macros for type generic mathematical operations

threads.h

An optional header that defines macros, types, and functions that support programming with multiple threads of execution

time.h

Defines macros and functions supporting operations with dates and times, including the ability to determine elapsed times during program execution

uchar.h

Defines types and functions for working with Unicode characters

wchar.h

Defines types and functions for working with wide character data

wctype.h

Defines functions for classifying and mapping wide characters. These include towupper() and towlower() for converting to uppercase and lowercase, respectively, and iswupper() and iswlower() functions for testing wide characters

Index

abort() function

Accessing array elements

Address of operator

American Standard Code for Information Interchange (ASCII)

AND operator (&&)

any_function()

Application programming interface (API)

Arguments

Arithmetic expression

array_op() function

Arrays

access elements

and addresses

address of operator

& operator

memory address

memory variables

output

scanf() function

variables of type double

variables of type long

application

average ten scores

element values

for loop, loop counts

loop control variable

variable calculation

constants

declaration

definition

dimension

element address

elements

evaluation

formatted input from

formatted output to

index value

initialization of elements

multidimensional arrays

application, know hat size

cranium variable

4 × 10 array

headsize array element

initialization

main () function

memory allocation

one-dimension

size array

three-dimension

3 × 5 element array

two-dimension

notation

off-by-one error

organization, in memory

program design

analysis

main game loop

problem

select a square

valid square number

winning line next

winning player number

programming without

sizeof operator

strings

sum by count

variable length

average grade calculation

dimensions

nGrades variables

symbol __STDC_NO_VLA__

Arrays of structures

ASCII character code

asctime()

asctime_s()

assert() macro

assert.h

Assertion

compile-time

runtime

switching off

atexit() function

at_quick_exit() function

Automatic variables

vs. static variables

code

count

definition

initialization

output

average() function

Backslash ()

Big-endian and little-endian systems

Binary file

opening

reading

updating

writing

Binary mode

Binary numbers

Binary operator

Binary stream

Binary system

Binary trees

construction

add_node()

arguments

count member

create_node()

do-while loop

integer storage

memory allocation, node structure

node addition

pLeft and pRight members

pRoot

recursion

root node creation

data order

long integer

nodes

NULL pointer

storing integers

structure

traverse

ascending/descending sequence

do-while loop

free_nodes()

integer list

list_nodes()

sorting integers

Bit fields

Bitwise operators

AND operator (&)

convert characters to lowercase/uppercase

definition

integer variable

mask

op=

OR operator (|)

program

shift operators

unary operator (~)

working

XOR operator (^)

block1 identifier

bool variables

Boolean expressions

Boolean values

Boundary alignment

Breadth-first search (BFS)

break statement

Buffering file operations

Byte

byte_count

Byte orientation

calendar_start

calloc() function

cats variable

% character

^ character

0 character

Character conversion

conditional operator

ctype.h

for loops

output

strstr() function

substring array

Character reading

Characters

in input format string

output

single character input

using scanf_s()

Character stream

CHAR_MAX

CHAR_MIN

chart_string()

clock() function

Clock ticks

close_file()

Command-line arguments

Compilation

Compiler error

Compile-time assertions

complex.h

Complex number

addition

arithmetic operations

compiler support

_Complex keyword

in complex plane

conjf() and conjl() functions

conjugate

creal() function

definition

division

double complex type

equality

float complex values

_Imaginary keyword

imaginary part

imaginary unit

imaginary value casting

modulus

multiplication

real part

types

Computer arithmetic

big-and little-endian systems

binary numbers

floating-point numbers

hexadecimal numbers

negative binary numbers

computer_move() function

Concatenating strings

Conditional operator

conio.h

const modifier

Constant arrays

Constant pointers

const char *

const parameters

continue statement

Conversion characters

Conversion specifiers

Copying strings

C programs

arguments

comments

common mistakes

control characters

creation

compiler

editing

execution stage

first program

linker

development

detailed design

implementation

testing

understanding the problem

editing, first program

elements

error checking

functions

keywords

longer program

main() function

modular programming

preprocessing directive

preprocessor

printf() function

quotation display

segmentation

standard library

text string

trigraph sequences

cpu_start

cpu_time

ctime() function

ctime_s() function

ctype.h

currency_symbol pointer

Data structures

and functions

pointers

return value

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Table of Contents for
Back Matter