Pointers in C++

Study Notes

Definition
- A pointer is a variable that holds the memory address of another variable.
Declaration
- Syntax: data_type *pointer_name;
  - Example: int *ptr; declares a pointer to an integer.
Initialization
- Use the address-of operator & to initialize a pointer.
  - Example:
```
int value = 5;
int *ptr = &value; // ptr now holds the address of value
```
Dereferencing
- Access the value stored at the address the pointer points to using the dereference operator *.
  - Example:
```
int num = *ptr; // num now holds the value 5
```
Null Pointers
- A pointer that doesn’t point to any memory location, initialized using nullptr.
  - Example: int *ptr = nullptr;
Pointer Arithmetic
- Pointers can be incremented or decremented to point to different elements in an array.
  - Example:
```
int arr[] = {10, 20, 30};
int *ptr = arr; // points to arr[0]
ptr++; // now points to arr[1]
```
Pointers and Arrays
- An array name acts as a pointer to its first element.
  - Example:
```
int arr[3] = {1, 2, 3};
int *ptr = arr; // ptr points to arr[0]
```

Dynamic Memory Allocation

Use new to allocate memory dynamically and delete to free it.

Example:

int *ptr = new int; // allocates memory for an integer
*ptr = 10; // sets the allocated memory to 10
delete ptr; // frees the memory

Function Pointers
- Pointers can point to functions, allowing functions to be passed as arguments.
  - Example:
```
void function() { /* do something */ }
void (*funcPtr)() = &function; // funcPtr points to function
```
Pointers to Pointers
- A pointer can point to another pointer.
  - Example:
```
int **ptrToPtr;
```
Common Errors
- Dereferencing a null pointer leads to undefined behavior.
- Memory leaks can occur if dynamically allocated memory is not properly deleted.
Best Practices
- Always initialize pointers.
- Avoid using dangling pointers (pointers that point to freed memory).
- Use smart pointers (e.g., std::unique_ptr, std::shared_ptr) in C++11 and later for better memory management.

A pointer is a variable that stores the memory address of another variable.
Pointers are declared using the syntax: data_type *pointer_name;
To initialize a pointer, use the address-of operator (&) to get the memory address of the variable you want to point to.
You can access the value stored at the address a pointer points to using the dereference operator (*).
A null pointer doesn't point to any memory location and is initialized using nullptr.
Pointers can be incremented or decremented to move to the next or previous element in an array.
An array name acts as a pointer to its first element.
new dynamically allocates memory for a variable, and delete releases it.
Function pointers allow passing functions as arguments.
Pointers to pointers can be used to store the addresses of other pointers.
Dereferencing a null pointer will lead to undefined behavior.
new must be paired with delete to prevent memory leaks.
Always initialize pointers to prevent pointing to incorrect memory locations.
Dangling pointers are a risk when dealing with pointers and dynamically allocated memory. An example of a dangling pointer is if a pointer points to a memory location, and that memory location, is then deallocated. The pointer would then be considered a dangling pointer.
Smart pointers such as std::unique_ptr and std::shared_ptr can simplify memory management in C++.