C++ Pointers Basics and Arithmetic

Pointer Basics

• Definition: A pointer is a variable that stores the memory address of another variable.
• Declaration: Syntax to declare a pointer:

  int* ptr;  // Pointer to an integer
  char* cptr; // Pointer to a character
  

• Initialization: Assigning a pointer to the address of a variable:

  int var = 5;
  int* ptr = &var; // ptr now holds the address of var
  

• Dereferencing: Accessing the value stored at the address a pointer points to:

  int value = *ptr; // value now holds 5
  

• Null Pointer: A pointer that does not point to any valid memory, often initialized as:

  int* ptr = nullptr; // Safe to use
  

Pointer Arithmetic

• Concept: Pointer arithmetic allows for manipulation of pointer values based on data type size.
• Incrementing: When a pointer is incremented, it moves to the next memory location of the type it points to:

  int arr[] = {10, 20, 30};
  int* ptr = arr; // points to arr[0]
  ptr++; // now points to arr[1]
  

• Decrementing: Similar to incrementing, decrementing a pointer moves it to the previous memory location:

  ptr--; // now points back to arr[0]
  

• Adding an Integer: Adding an integer to a pointer adds that many elements of the pointer’s type:

  ptr += 2; // points to arr[2]
  

• Subtracting Pointers: The difference between two pointers of the same type gives the number of elements between them:

  int* start = &arr[0];
  int* end = &arr[2];
  int distance = end - start; // distance is 2
  

Pointer Basics

• A pointer is a variable designed to hold the memory address of another variable, enabling indirect access to its value.
• Declaration syntax for a pointer in C++ involves the data type followed by an asterisk, e.g., int* ptr; for an integer pointer or char* cptr; for a character pointer.
• Initialization involves assigning a pointer to the address of an existing variable using the address-of operator (&), e.g., int* ptr = &var; where ptr points to var.
• Dereferencing a pointer allows access to the value at the memory address it holds, done using the asterisk operator, e.g., int value = *ptr; retrieves the value stored at that address.
• A null pointer points to no valid memory location and can be safely initialized with nullptr, e.g., int* ptr = nullptr;.

Pointer Arithmetic

• Pointer arithmetic involves adjusting pointer values based on the size of the data type, facilitating navigation through memory.
• Incrementing a pointer (ptr++) moves it to the next memory position corresponding to its data type, allowing traversal of arrays.
• Decrementing a pointer (ptr--) returns it to the previous memory location, enabling reverse navigation.
• Adding an integer to a pointer moves it forward by that many elements of its type, e.g., ptr += 2; advances the pointer two positions in the array.
• Subtracting two pointers of the same type yields the number of elements between them, allowing for distance measurement in arrays, calculated as int distance = end - start;.