Table of Contents for
Intermediate C Programming

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Intermediate C Programming by Yung-Hsiang Lu Published by CRC Press, 2015
  1. Front Cover
  2. Contents (1/2)
  3. Contents (2/2)
  4. List of Figures (1/2)
  5. List of Figures (2/2)
  6. List of Tables
  7. Foreword
  8. Preface
  9. Author, Reviewers, and Artist
  10. Rules in Software Development
  11. Source Code
  12. I. Computer Storage: Memory and File
  13. 1. Program Execution (1/2)
  14. 1. Program Execution (2/2)
  15. 2. Stack Memory (1/5)
  16. 2. Stack Memory (2/5)
  17. 2. Stack Memory (3/5)
  18. 2. Stack Memory (4/5)
  19. 2. Stack Memory (5/5)
  20. 3. Prevent, Detect, and Remove Bugs (1/2)
  21. 3. Prevent, Detect, and Remove Bugs (2/2)
  22. 4. Pointers (1/6)
  23. 4. Pointers (2/6)
  24. 4. Pointers (3/6)
  25. 4. Pointers (4/6)
  26. 4. Pointers (5/6)
  27. 4. Pointers (6/6)
  28. 5. Writing and Testing Programs (1/4)
  29. 5. Writing and Testing Programs (2/4)
  30. 5. Writing and Testing Programs (3/4)
  31. 5. Writing and Testing Programs (4/4)
  32. 6. Strings (1/3)
  33. 6. Strings (2/3)
  34. 6. Strings (3/3)
  35. 7. Programming Problems and Debugging (1/4)
  36. 7. Programming Problems and Debugging (2/4)
  37. 7. Programming Problems and Debugging (3/4)
  38. 7. Programming Problems and Debugging (4/4)
  39. 8. Heap Memory (1/3)
  40. 8. Heap Memory (2/3)
  41. 8. Heap Memory (3/3)
  42. 9. Programming Problems Using Heap Memory (1/4)
  43. 9. Programming Problems Using Heap Memory (2/4)
  44. 9. Programming Problems Using Heap Memory (3/4)
  45. 9. Programming Problems Using Heap Memory (4/4)
  46. 10. Reading and Writing Files (1/3)
  47. 10. Reading and Writing Files (2/3)
  48. 10. Reading and Writing Files (3/3)
  49. 11. Programming Problems Using File (1/2)
  50. 11. Programming Problems Using File (2/2)
  51. II. Recursion
  52. 12. Recursion (1/4)
  53. 12. Recursion (2/4)
  54. 12. Recursion (3/4)
  55. 12. Recursion (4/4)
  56. 13. Recursive C Functions (1/4)
  57. 13. Recursive C Functions (2/4)
  58. 13. Recursive C Functions (3/4)
  59. 13. Recursive C Functions (4/4)
  60. 14. Integer Partition (1/5)
  61. 14. Integer Partition (2/5)
  62. 14. Integer Partition (3/5)
  63. 14. Integer Partition (4/5)
  64. 14. Integer Partition (5/5)
  65. 15. Programming Problems Using Recursion (1/5)
  66. 15. Programming Problems Using Recursion (2/5)
  67. 15. Programming Problems Using Recursion (3/5)
  68. 15. Programming Problems Using Recursion (4/5)
  69. 15. Programming Problems Using Recursion (5/5)
  70. III. Structure
  71. 16. Programmer-Defined Data Types (1/6)
  72. 16. Programmer-Defined Data Types (2/6)
  73. 16. Programmer-Defined Data Types (3/6)
  74. 16. Programmer-Defined Data Types (4/6)
  75. 16. Programmer-Defined Data Types (5/6)
  76. 16. Programmer-Defined Data Types (6/6)
  77. 17. Programming Problems Using Structure (1/4)
  78. 17. Programming Problems Using Structure (2/4)
  79. 17. Programming Problems Using Structure (3/4)
  80. 17. Programming Problems Using Structure (4/4)
  81. 18. Linked Lists (1/3)
  82. 18. Linked Lists (2/3)
  83. 18. Linked Lists (3/3)
  84. 19. Programming Problems Using Linked List (1/2)
  85. 19. Programming Problems Using Linked List (2/2)
  86. 20. Binary Search Trees (1/4)
  87. 20. Binary Search Trees (2/4)
  88. 20. Binary Search Trees (3/4)
  89. 20. Binary Search Trees (4/4)
  90. 21. Parallel Programming Using Threads (1/5)
  91. 21. Parallel Programming Using Threads (2/5)
  92. 21. Parallel Programming Using Threads (3/5)
  93. 21. Parallel Programming Using Threads (4/5)
  94. 21. Parallel Programming Using Threads (5/5)
  95. IV. Applications
  96. 22. Finding the Exit of a Maze (1/5)
  97. 22. Finding the Exit of a Maze (2/5)
  98. 22. Finding the Exit of a Maze (3/5)
  99. 22. Finding the Exit of a Maze (4/5)
  100. 22. Finding the Exit of a Maze (5/5)
  101. 23. Image Processing (1/3)
  102. 23. Image Processing (2/3)
  103. 23. Image Processing (3/3)
  104. 24. Huffman Compression (1/10)
  105. 24. Huffman Compression (2/10)
  106. 24. Huffman Compression (3/10)
  107. 24. Huffman Compression (4/10)
  108. 24. Huffman Compression (5/10)
  109. 24. Huffman Compression (6/10)
  110. 24. Huffman Compression (7/10)
  111. 24. Huffman Compression (8/10)
  112. 24. Huffman Compression (9/10)
  113. 24. Huffman Compression (10/10)
  114. A. Linux
  115. B. Version Control
  116. C. Integrated Development Environments (IDE) (1/3)
  117. C. Integrated Development Environments (IDE) (2/3)
  118. C. Integrated Development Environments (IDE) (3/3)
290 Intermediate C Programming
DecP ack_de stroy ( dp );29
return EXIT _SUCCES S ;30
}31
Here is the Makefile:
GCC = gcc1
CFLAGS = -g - Wall - Wshadow2
VALGRIND = valgrind -- tool = memc h eck -- verbose --log - file3
4
decpack : d e cp ack . c decpack . h main .c5
$( GCC ) $ ( CFLAGS ) decpack .c main .c -o $@6
$( VALGRIND )= valgr indlog ./ decpack7
8
clean :9
/ bin / rm -f *. o decpack * log10
17.3 Binary File and Pointer
Section 16.6 describes how to use fread and fwrite to read and write the attributes of
an object. What happens if the object contains one or more pointers? Consider the following
example:
// str uctfile .c1
#in clude < stdio .h >2
#in clude < stdlib .h >3
#in clude < time .h >4
#pragma pack (1) // tell compiler not to pad any space5
typedef s t ru ct6
{7
int length ;8
int * data ;9
} Array ;10
// for simplicity , this progr a m does not check errors11
int main ( i n t argc , char ** argv )12
{13
int length = 10;14
char * f i lename = " data ";15
// create an object16
Array * aptr1 = NULL ;17
printf (" sizeof ( aptr1 ) = % d\n " , ( i nt ) s i z e o f ( aptr1 ) );18
aptr1 = malloc ( s i z e o f ( Array ) );19
printf (" sizeof ( aptr1 ) = %d , sizeof ( Array ) = %d\ n" ,20
( i n t ) s i z e o f ( aptr1 ) , ( i n t ) s i z e o f ( Array )) ;21
// allocat e memory for the data22
aptr1 -> length = length ;23
aptr1 -> data = malloc ( s i z e o f ( i n t ) * ( aptr1 -> length )) ;24
printf (" sizeof ( aptr1 ): %d , sizeof ( aptr1 -> data ): %d \n" ,25
( i n t ) s i z e o f ( aptr1 ) , ( i n t ) s i z e o f ( aptr1 -> data )) ;26
Programming Problems Using Structure 291
// ini tialize the values of the array27
int ind ;28
for ( ind = 0; ind < ( aptr1 -> length ); ind ++)29
{30
aptr1 -> data [ ind ] = ind ;31
}32
// save the data to a file33
FILE * fptr = fopen ( filename , "w ");34
// write the data to the file35
i f ( fwrite ( aptr1 , s i z e o f ( Array ) , 1, fptr ) != 1)36
{37
// fwrite fail38
return EXIT _FAILUR E ;39
}40
printf (" ftell ( fptr ) = % d\n ", ( in t ) ftell ( fptr )) ;41
fclose ( fptr );42
43
// fill the array with random numbers44
// ensure the heap contains garbage before re l easing it45
srand ( time ( NULL )) ; // set the seed of the random number46
for ( ind = 0; ind < ( aptr1 -> length ); ind ++)47
{48
aptr1 -> data [ ind ] = rand ();49
}50
51
// release memory52
free ( aptr1 -> data );53
free ( aptr1 );54
// read the data from the file55
Array * aptr2 = NULL ;56
aptr2 = malloc ( s i z e o f ( Array ) );57
fptr = fopen ( filename , " r") ;58
i f ( fread ( aptr2 , s i z e o f ( Array ) , 1, fptr ) != 1)59
{60
// fread fail61
return EXIT _FAILUR E ;62
}63
// add the data64
int sum = 0;65
for ( ind = 0; ind < ( aptr2 -> length ); ind ++)66
{67
sum += aptr2 -> data [ ind ];68
}69
printf (" sum = %d\ n" , sum ) ;70
// release memory71
free ( aptr2 );72
return EXIT _SUCCES S ;73
}74
292 Intermediate C Programming
Assume this program runs on a 64-bit (8 bytes) machine and furthermore, that each
integer uses 4 bytes. Also assume that the program never returns EXIT FAILURE. What is
the output of this program? Here is a sample output:
sizeof(arrptr1) = 8
sizeof(arrptr1) = 8, sizeof(Array) = 12
sizeof(arrptr1) = 8, sizeof(arrptr1 -> data) = 8
ftell(fptr) = 12
sum = 1289469162
The value of sum changes if the program is run again. The array’s elements are set to
random values (line 49) after the data has been written to the file (line 36). When line
59 reads the data, the elements’ values should be 0, 1, 2, ..., right? Wrong. If we run this
program with valgrind, it will tell us that the program has an “Invalid read” at line 68.
Why? The reason is that we cannot use fwrite to save the value of a pointer because this
value is a memory address. The address is meaningless when saved into a file. Instead of
saving the address, the program must save the data stored at the address. To summarize, it
makes no sense to write memory addresses to a file; nor does it make sense to read memory
addresses from a file.