Introduction to C language / PDF
Introduction to C / PDF
Table of Contents:
1.1 Why learn C? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Program organization . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Hello . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Program input . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
What are “function parameters” ? . . . . . . . . . . . . . . . . . 15
Console mode programs and windows programs . . . . . . . . . 16
1.4 An overview of the compilation process . . . . . . . . . . . . . . . . . . 17
1.4.1 The run time environment . . . . . . . . . . . . . . . . . . . . . 18
We wrote the program first . . . . . . . . . . . . . . . . . . . . 18
We compiled our design . . . . . . . . . . . . . . . . . . . . . . 19
Run time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.5 An overview of the standard libraries . . . . . . . . . . . . . . . . . . . 19
The “stdheaders.h” include file . . . . . . . . . . . . . . . . . . 20
1.5.1 Passing arguments to a program . . . . . . . . . . . . . . . . . 20
Implementation details . . . . . . . . . . . . . . . . . . . . . . . 23
1.6 Iteration constructs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.6.1 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.6.2 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6.3 do . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.6.4 break and continue . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.7 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.7.1 What is a type? . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.7.2 Types classification . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.7.3 Integer types . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.7.4 Floating types . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.7.5 Compatible types . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.7.6 Incomplete types . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.7.7 Qualified types . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.7.8 Casting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.7.9 The basic types . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.8 Declarations and definitions . . . . . . . . . . . . . . . . . . . . . . . . 31
1.8.1 Variable declaration . . . . . . . . . . . . . . . . . . . . . . . . 33
1.8.2 Function declarations . . . . . . . . . . . . . . . . . . . . . . . 35
1.8.3 Function definitions . . . . . . . . . . . . . . . . . . . . . . . . 36
1.8.4 Scope of identifiers . . . . . . . . . . . . . . . . . . . . . . . . . 37
3
1.8.5 Linkage and duration of objects . . . . . . . . . . . . . . . . . . 37
1.8.6 Variable definition . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.8.7 Statement syntax . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.9 Errors and warnings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.10 Input and output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.10.1 Predefined devices . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.10.2 The typical sequence of operations . . . . . . . . . . . . . . . . 42
1.10.3 Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.10.4 Other input/output functions . . . . . . . . . . . . . . . . . . . 48
The current position . . . . . . . . . . . . . . . . . . . . . . . . 48
1.10.5 File buffering . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Error conditions . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.11 Commenting the source code . . . . . . . . . . . . . . . . . . . . . . . 50
1.11.1 Describing a function . . . . . . . . . . . . . . . . . . . . . . . . 51
1.11.2 Describing a file . . . . . . . . . . . . . . . . . . . . . . . . . . 53
1.12 An overview of the whole language . . . . . . . . . . . . . . . . . . . . 53
1.12.1 Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
1.12.2 Declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
1.12.3 Pre-processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
1.12.4 Control-flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
1.12.5 Extensions of lcc-win . . . . . . . . . . . . . . . . . . . . . . . . 62
2 A closer view 65
2.1 Identifiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.1.1 Identifier scope and linkage . . . . . . . . . . . . . . . . . . . . 66
2.2 Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.2.1 Evaluation of constants . . . . . . . . . . . . . . . . . . . . . . 67
Constant expressions . . . . . . . . . . . . . . . . . . . . . . . . 68
2.2.2 Integer constants . . . . . . . . . . . . . . . . . . . . . . . . . . 69
2.2.3 Floating constants . . . . . . . . . . . . . . . . . . . . . . . . . 70
2.2.4 Character string constants . . . . . . . . . . . . . . . . . . . . . 70
2.2.5 Character abbreviations . . . . . . . . . . . . . . . . . . . . . . 71
2.3 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
2.3.1 Variable length arrays. . . . . . . . . . . . . . . . . . . . . . . . 74
2.3.2 Array initialization . . . . . . . . . . . . . . . . . . . . . . . . . 74
2.3.3 Compound literals . . . . . . . . . . . . . . . . . . . . . . . . . 75
2.4 Function calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
2.4.1 Prototypes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.4.2 Functions with variable number of arguments. . . . . . . . . . . 77
Implementation details . . . . . . . . . . . . . . . . . . . . . . . 77
2.4.3 stdcall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
2.4.4 Inline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
2.5 Assignment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.6 The four operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.6.1 Integer division . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.6.2 Overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
2.6.3 Postfix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
2.7 Conditional operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
2.8 Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
2.8.1 Should we use the register keyword? . . . . . . . . . . . . . . . 82
2.9 Sizeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
2.10 Enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
2.10.1 Const. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Implementation details . . . . . . . . . . . . . . . . . . . . . . . 83
2.11 Goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
2.12 Break and continue statements . . . . . . . . . . . . . . . . . . . . . . 84
2.13 Return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.13.1 Two types of return statements . . . . . . . . . . . . . . . . . . 85
2.13.2 Returning a structure . . . . . . . . . . . . . . . . . . . . . . . 86
2.13.3 Never return a pointer to a local variable . . . . . . . . . . . . 86
2.13.4 Unsigned . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.14 Null statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.15 Switch statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
2.16 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
2.17 Bitwise operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
2.18 Shift operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
2.19 Address-of operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.20 Indirection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
2.21 Sequential expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
2.22 Casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
2.22.1 When to use casts . . . . . . . . . . . . . . . . . . . . . . . . . 93
2.22.2 When not to use casts . . . . . . . . . . . . . . . . . . . . . . . 94
2.23 Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.24 Predefined identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
2.25 Precedence of the different operators. . . . . . . . . . . . . . . . . . . . 96
2.26 The printf family . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
2.26.1 Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
2.26.2 The minimum field width . . . . . . . . . . . . . . . . . . . . . 99
2.26.3 The precision . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.26.4 The conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.26.5 Scanning values . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
2.27 Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.27.1 Operations with pointers . . . . . . . . . . . . . . . . . . . . . 105
2.27.2 Addition or subtraction of a displacement: pointer arithmetic . 106
2.27.3 Subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
2.27.4 Relational operators . . . . . . . . . . . . . . . . . . . . . . . . 107
2.27.5 Null pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
2.27.6 Pointers and arrays . . . . . . . . . . . . . . . . . . . . . . . . . 107
2.27.7 Assigning a value to a pointer . . . . . . . . . . . . . . . . . . . 107
2.27.8 References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
2.27.9 Why pointers? . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.28 setjmp and longjmp . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.28.1 General usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2.28.2 Register variables and longjmp . . . . . . . . . . . . . . . . . . 112
2.29 Time and date functions . . . . . . . . . . . . . . . . . . . . . . . . . . 113
3 Simple programs 117
3.1 strchr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3.1.1 How can strchr fail? . . . . . . . . . . . . . . . . . . . . . . . . 117
3.2 strlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
3.2.1 A straightforward implementation . . . . . . . . . . . . . . . . 118
3.2.2 An implementation by D. E. Knuth . . . . . . . . . . . . . . . 118
3.2.3 How can strlen fail? . . . . . . . . . . . . . . . . . . . . . . . . 120
3.3 ispowerOfTwo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
3.3.1 How can this program fail? . . . . . . . . . . . . . . . . . . . . 121
3.3.2 Write ispowerOfTwo without any loops . . . . . . . . . . . . . . 121
3.4 signum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
3.5 strlwr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.5.1 How can this program fail? . . . . . . . . . . . . . . . . . . . . 123
3.6 paste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.6.1 How can this program fail?. . . . . . . . . . . . . . . . . . . . . 126
3.7 Using arrays and sorting . . . . . . . . . . . . . . . . . . . . . . . . . . 128
3.7.1 How to sort arrays . . . . . . . . . . . . . . . . . . . . . . . . . 131
3.7.2 Other qsort applications . . . . . . . . . . . . . . . . . . . . . . 136
3.7.3 Quicksort problems . . . . . . . . . . . . . . . . . . . . . . . . . 138
3.8 Counting words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
3.8.1 The organization of the table . . . . . . . . . . . . . . . . . . . 142
3.8.2 Memory organization . . . . . . . . . . . . . . . . . . . . . . . . 144
3.8.3 Displaying the results . . . . . . . . . . . . . . . . . . . . . . . 146
3.8.4 Code review . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
3.9 Hexdump . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
3.9.1 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
3.9.2 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
3.10 Text processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
3.10.1 Detailed view . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
ProcessChar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
ReadLongComment and ReadLineComment . . . . . . . . . . . 158
ReadCharConstant . . . . . . . . . . . . . . . . . . . . . . . . . 158
OutputStrings . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
3.10.2 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
3.10.3 Exercises: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
3.11 Using containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
4 Structures and unions 163
4.1 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
4.1.1 Structure size . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
4.1.2 Using the pragma pack feature . . . . . . . . . . . . . . . . . . 168
4.1.3 Structure packing in other environments . . . . . . . . . . . . . 169
Gcc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Hewlett Packard . . . . . . . . . . . . . . . . . . . . . . . . . . 169
IBM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Comeau computing C . . . . . . . . . . . . . . . . . . . . . . . 169
Microsoft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
4.1.4 Bit fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
4.2 Unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
4.3 Using structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
4.4 Basic data structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
4.4.1 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
4.4.2 Hash tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
4.4.3 The container library of lcc-win . . . . . . . . . . . . . . . . . . 180
4.5 Fine points of structure use . . . . . . . . . . . . . . . . . . . . . . . . 181
5 Simple programs using structures 183
5.1 Reversing a linked list . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
5.1.1 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
An improvement . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Preconditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
6 A closer look at the pre-processor 189
6.1 Preprocessor commands . . . . . . . . . . . . . . . . . . . . . . . . . . 191
6.1.1 Preprocessor macros . . . . . . . . . . . . . . . . . . . . . . . . 191
6.2 Conditional compilation . . . . . . . . . . . . . . . . . . . . . . . . . . 192
6.3 The pragma directive . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
6.4 Token concatenation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
6.5 The # operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
6.6 The include directive . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
6.7 Things to watch when using the preprocessor . . . . . . . . . . . . . . 195
7 More advanced stuff 197
7.1 Using function pointers . . . . . . . . . . . . . . . . . . . . . . . . . . 197
7.2 Using the "signal" function . . . . . . . . . . . . . . . . . . . . . . . . 202
7.2.1 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
longjmp usage . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Guard pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
8 Advanced C programming with lcc-win 205
8.1 Operator overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
8.1.1 What is operator overloading? . . . . . . . . . . . . . . . . . . 206
8.1.2 Rules for the arguments . . . . . . . . . . . . . . . . . . . . . . 209
8.1.3 Name resolution . . . . . . . . . . . . . . . . . . . . . . . . . . 210
8.1.4 Differences to C++ . . . . . . . . . . . . . . . . . . . . . . . . . 210
8.2 Generic functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
8.2.1 Usage rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
8.3 Default arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
8.4 References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
9 Numerical programming 215
9.1 Floating point formats . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
9.1.1 Float (32 bit) format . . . . . . . . . . . . . . . . . . . . . . . . 216
9.1.2 Long double (80 bit) format . . . . . . . . . . . . . . . . . . . . 217
9.1.3 The qfloat format . . . . . . . . . . . . . . . . . . . . . . . . . . 218
9.1.4 Special numbers . . . . . . . . . . . . . . . . . . . . . . . . . . 218
9.2 Range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
9.3 Precision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
9.4 Understanding exactly the floating point format . . . . . . . . . . . . . 224
9.5 Rounding modes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
9.6 The machine epsilon . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
9.7 Rounding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
9.8 Using the floating point environment . . . . . . . . . . . . . . . . . . . 228
9.8.1 The status flags . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
9.8.2 Reinitializing the floating point environment . . . . . . . . . . . 229
9.9 Numerical stability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
9.9.1 Algebra doesn’t work . . . . . . . . . . . . . . . . . . . . . . . . 232
9.9.2 Underflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
9.10 The math library . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
10 Memory management and memory layout 241
10.1 Functions for memory management . . . . . . . . . . . . . . . . . . . . 243
10.2 Memory management strategies . . . . . . . . . . . . . . . . . . . . . . 243
10.2.1 Static buffers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Advantages: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Drawbacks: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
10.3 Stack based allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Advantages: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Drawbacks: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
10.3.1 “Arena” based allocation . . . . . . . . . . . . . . . . . . . . . . 245
Advantages: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Drawbacks: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
10.4 The malloc / free strategy . . . . . . . . . . . . . . . . . . . . . . . . 246
Advantages: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Drawbacks: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
10.5 The malloc with no free strategy . . . . . . . . . . . . . . . . . . . . . 247
Advantages: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Drawbacks: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
10.6 Automatic freeing (garbage collection). . . . . . . . . . . . . . . . . . . 247
Advantages: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Drawbacks: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
10.7 Mixed strategies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
10.8 A debugging implementation of malloc . . . . . . . . . . . . . . . . . . 248
10.8.1 Improving allocate/release . . . . . . . . . . . . . . . . . . . . 251
11 The libraries of lcc-win 253
11.1 The regular expressions library. A “grep” clone. . . . . . . . . . . . . . 254
11.2 Using qfloats: Some examples . . . . . . . . . . . . . . . . . . . . . . . 258
Contents 9
11.3 Using bignums: some examples . . . . . . . . . . . . . . . . . . . . . . 258
12 Pitfalls of the C language 261
12.1 Defining a variable in a header file . . . . . . . . . . . . . . . . . . . . 261
12.2 Confusing = and == . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
12.3 Forgetting to close a comment . . . . . . . . . . . . . . . . . . . . . . . 261
12.4 Easily changed block scope. . . . . . . . . . . . . . . . . . . . . . . . . 262
12.5 Using increment or decrement more than once in an expression. . . . . 262
12.6 Unexpected Operator Precedence . . . . . . . . . . . . . . . . . . . . . 262
12.7 Extra Semi-colon in Macros . . . . . . . . . . . . . . . . . . . . . . . . 263
12.8 Watch those semicolons! . . . . . . . . . . . . . . . . . . . . . . . . . . 264
12.9 Assuming pointer size is equal to integer size . . . . . . . . . . . . . . 264
12.10Careful with unsigned numbers . . . . . . . . . . . . . . . . . . . . . . 264
12.11Changing constant strings . . . . . . . . . . . . . . . . . . . . . . . . . 264
12.12Indefinite order of evaluation . . . . . . . . . . . . . . . . . . . . . . . 265
12.13A local variable shadows a global one . . . . . . . . . . . . . . . . . . . 266
12.14Careful with integer wraparound . . . . . . . . . . . . . . . . . . . . . 266
12.15Problems with integer casting . . . . . . . . . . . . . . . . . . . . . . . 267
12.16Octal numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
12.17Wrong assumptions with realloc . . . . . . . . . . . . . . . . . . . . . . 267
12.18Be careful with integer overflow . . . . . . . . . . . . . . . . . . . . . . 268
12.18.1Overflow in calloc . . . . . . . . . . . . . . . . . . . . . . . . . 268
12.19The abs macro can yield a negative number. . . . . . . . . . . . . . . . 268
12.20Adding two positive numbers might make the result smaller. . . . . . . 269
12.21Assigning a value avoiding truncation . . . . . . . . . . . . . . . . . . 269
12.22The C standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
12.22.1 Standard word salads . . . . . . . . . . . . . . . . . . . . . . . 270
12.22.2A buffer overflow in the C standard document . . . . . . . . . . 272
Getting rid of buffer overflows . . . . . . . . . . . . . . . . . . . 273
Buffer overflows are not inevitable. . . . . . . . . . . . . . . . . 274
The attitude of the committee . . . . . . . . . . . . . . . . . . 274
12.22.3A better implementation of asctime . . . . . . . . . . . . . . . 275
13 Bibliography 279
Appendices 281
.1 Using the command line compiler . . . . . . . . . . . . . . . . . . . . . 283
Click here for Download PDF / FREE
Introduction to C / PDF
0 commentaires: