go back to content

1. Introduction

• Pointers and Memory
  • Why You Should Become Proficient with Pointers
  • Declaring Pointers
  • How to Read a Declaration
  • Address of Operator
  • Displaying Pointer Values
  • Virtual Memory and Pointers
  • Dereferencing a Pointer Using the Indirection Operator
  • Pointers to Functions
• The Concept of Null
  • To NULL or not to NULL
  • Pointer to void
  • Global and static pointers
• Pointer Size and Types
  • Memory Models
• Predefined Pointer-Related Types
  • Understanding size_t
  • Using the sizeof operator with pointers
  • Using intptr_t and uintptr_t
• Pointer Operators
• Pointer Arithmetic
  • Adding an integer to a pointer
  • Pointers to void and addition
  • Subtracting an integer from a pointer
  • Subtracting two pointers
• Comparing Pointers
• Common Uses of Pointers
  • Multiple Levels of Indirection
• Constants and Pointers
  • Pointers to a constant
  • Constant pointers to nonconstants
  • Constant pointers to constants
  • Pointer to (constant pointer to constant)
• Summary

2. Dynamic Memory Management in C

• Dynamic Memory Allocation
  • Memory Leaks
  • Losing the address
• Dynamic Memory Allocation Functions
  • Using the malloc Functions
  • To Cast or not to Cast
  • Failing to allocate memory
  • Not using the right size for the malloc function
  • Determining the amount of memory allocated
  • Using malloc with static and global Pointers
  • using the calloc Function
  • Using the realloc Function
  • The alloca Function and Variable Length Arrays
• Deallocating Memory Using the free Function
  • Assigning NULL to a Freed Pointer
  • Double Free
  • The Heap and System Memory
  • Freeing Memory upon Program Termination
• Dangling Pointers
  • Dangling Pointer Examples
  • Dealing with Dangling Pointers
  • Debug Version Support for Detecting Memory Leaks
  • Dynamic Memory Allocation Technologies
  • Garbage Collection in C
  • Resource Acquisition Is Initialization
  • Using Exception Handlers 56 Summary

3. Pointers and Functions

• Program Stack and Heap
  • Program Stack
  • Organization of a Stack Frame
• Passing and Returning by Pointer
  • Passing Data Using a Pointer
  • Passing Data by Value
  • Passing a Pointer to a Constant
  • Returning a Pointer
  • Pointers to Local Data
  • Passing Null Pointers
  • Passing a Pointer to a Pointer
  • Writing your own free function
• Function Pointers
  • Declaring Function Pointers
  • Using a Function Pointer
  • Passing Function Pointers
  • Returning Function Pointers
  • Using an Array of Function Pointers
  • Comparing Function Pointers
  • Casting Function Pointers
• Summary

4. Pointers and Arrays

• Quick Review of Arrays
  • One-Dimensional Arrays
  • Two-Dimensional Arrays
  • Multidimensional Arrays
• Pointer Notation and Arrays
  • Debug *firstElementPointer++
  • Differences Between Arrays and Pointers
• Using malloc to Create a One-Dimensional Array
• Using the realloc Function to Resize an Array
• Passing a One-Dimensional Array
  • Using Array Notation
  • Using Pointer Notation
• Using a One-Dimensional Array of Pointers
• Pointers and Multidimensional Arrays
• Passing a Multidimensional Array
• Dynamically Allocating a Two-Dimensional Array
  • Allocating Potentially Noncontiguous Memory
  • Allocating Contiguous Memory
• Jagged Arrays and Pointers
• Summary

5. Pointers and Strings

• String Fundamentals
  • String Declaration
  • The String Literal Pool
  • When a string literal is not a constant
  • String Initialization
  • Initializing an array of char
  • Initializing a pointer to a char
  • Initializing a string from standard input
  • Summary of string placement
• Standard String Operations
  • Comparing Strings
  • Copying Strings
  • Concatenating Strings
• Passing Strings
  • Passing a Simple String
  • Passing a Pointer to a Constant char
  • Passing a String to Be Initialized
  • Passing Arguments to an Application
• Returning Strings
  • Returning the Address of a Literal
  • Returning the Address of Dynamically Allocated Memory
  • Returning the address of a local string
• Function Pointers and Strings
• Summary

6. Pointers and Structures

• Introduction
  • How Memory Is Allocated for a Structure
• Structure Deallocation Issues
• Avoiding malloc/free Overhead
• Using Pointers to Support Data Structures
  • Single-Linked List
  • Using Pointers to Support a Queue
  • Using Pointers to Support a Stack
  • Using Pointers to Support a Tree
• Summary 158

7. Security Issues And The Improper Use Of Pointers

1. Pointer Declaration and Initialization
2. Improper Pointer Declaration
3. Failure to Initialize a Pointer Before It Is Used
4. Dealing with Uninitialized Pointers
5. Pointer Usage Issues
6. Test for NULL
7. Misuse of the Dereference Operator
8. Dangling Pointers
9. Accessing Memory Outside the Bounds of an Array
10. Calculating the Array Size Incorrectly
11. Misusing the sizeof Operator
12. Always Match Pointer Types
13. Bounded Pointers
14. String Security Issues
15. Pointer Arithmetic and Structures
16. Function Pointer Issues
17. Memory Deallocation Issues
18. Double Free
19. Clearing Sensitive Data
20. Using Static Analysis Tools
21. Summary

8. Odds And Ends

1. Casting Pointers
2. Accessing a Special Purpose Address
3. Accessing a Port
4. Accessing Memory using DMA
5. Determining the Endianness of a Machine
6. Aliasing, Strict Aliasing, and the restrict Keyword
7. Using a Union to Represent a Value in Multiple Ways
8. Strict Aliasing
9. Using the restrict Keyword
10. Threads and Pointers
11. Sharing Pointers Between Threads
12. Using Function Pointers to Support Callbacks
13. Object-Oriented Techniques
14. Creating and Using an Opaque Pointer
15. Polymorphism in C
16. Summary