Chapter 21: Memory Access

21.1 Pointer Pathology

• Understanding Pointers:

  • Pointers store memory addresses, allowing indirect access to variables.

  • Syntax:

    int* ptr = &variable;
    

• Common Issues:

  • Dangling Pointers: Pointers referencing deallocated memory.

  • Null Pointers: Pointers initialized to nullptr to indicate they don't point to valid data.

  • Wild Pointers: Uninitialized pointers pointing to arbitrary memory locations.

• Best Practices:

  • Always initialize pointers.

  • Set pointers to nullptr after deallocation.

  • Use smart pointers (e.g., std::unique_ptr, std::shared_ptr) for automatic memory management.

21.2 Further Pointer Pathology with Heap Memory

• Heap Memory Management:

  • Dynamic memory allocation using new and deallocation using delete.

• Memory Leaks:

  • Occur when allocated memory isn't deallocated, leading to wasted resources.

• Double Deletion:

  • Deallocating the same memory twice, causing undefined behavior.

• Best Practices:

  • Match each new with a corresponding delete.

  • Use RAII (Resource Acquisition Is Initialization) principles to manage resources.

21.3 Memory Access Summary

• Key Points:

  • Proper pointer management is crucial for program stability.

  • Avoid common pitfalls like dangling pointers and memory leaks.

  • Utilize modern C++ features like smart pointers to simplify memory management.

21.4 Introduction to Arrays

• Definition:

  • Arrays are contiguous memory blocks storing elements of the same type.

• Declaration:

  int array[10];
  

• Accessing Elements:

  array[index] = value;
  

• Limitations:

  • Fixed size; cannot be resized dynamically.

  • Lack bounds checking; accessing out-of-bounds indices leads to undefined behavior.

21.5 Pointer Arithmetic

• Concept:

  • Allows traversal of array elements using pointers.

• Example:

  int* ptr = array;
  *(ptr + 1) = value;  // Accesses the second element
  

• Caution:

  • Pointer arithmetic should be performed within the bounds of the allocated memory to prevent undefined behavior.

21.6 Arrays, Functions, and Return Values

• Passing Arrays to Functions:

  • Arrays decay to pointers when passed to functions.

  • Function prototype:

    void function(int* array);
    

• Returning Arrays:

  • Functions cannot return arrays directly but can return pointers to arrays.

  • Ensure the lifetime of the returned array persists after the function call.

21.7 Different Kinds of Arrays

• Static Arrays:

  • Fixed size, allocated on the stack.

• Dynamic Arrays:

  • Size determined at runtime, allocated on the heap using new.

  • Example:

    int* dynamicArray = new int[size];
    

• Multidimensional Arrays:

  • Arrays of arrays, e.g., 2D arrays.

  • Declaration:

    int matrix[rows][columns];
    

21.8 Valid Pointer Operations

• Allowed Operations:

  • Assignment between pointers of the same type.

  • Pointer arithmetic (addition/subtraction of integers).

  • Comparison between pointers.

• Disallowed Operations:

  • Arithmetic between two pointers.

  • Dereferencing null or uninitialized pointers.

21.9 Arrays and Memory: Important Points

• Memory Layout:

  • Arrays are stored in contiguous memory locations.

• Size Calculation:

  • Use sizeof to determine the size of an array.

  • Example:

    sizeof(array) / sizeof(array[0]);  // Number of elements
    

• Decay to Pointers:

  • Arrays decay to pointers when passed to functions, losing size information.

21.10 Exercises: Memory Access

• Practice Problems:

  • Implement functions that manipulate arrays using pointers.

  • Identify and fix pointer-related issues in given code snippets.

21.11 Review Questions

• Sample Questions:

  • What is a dangling pointer, and how can it be avoided?

  • Explain the difference between static and dynamic arrays.

  • How does pointer arithmetic facilitate array traversal?

Abstract of Chapter 21

Chapter 21 covers the intricacies of memory access in C++, emphasizing pointers, arrays, and memory management. It explains common pointer issues (dangling, null, and wild pointers) and best practices for avoiding them. The chapter also explores heap memory allocation, pointer arithmetic, and various types of arrays. Understanding these concepts is essential for writing efficient and bug-free C++ programs, particularly when dealing with low-level memory operations.