What are the main problems associated with the use of pointers in C/C++?

• Dangling pointers: Point to freed memory. Dereferencing them leads to undefined behavior (crash, corrupted data).
• Memory leaks: Memory is allocated but becomes inaccessible (pointer lost) and cannot be freed. They accumulate, leading to resource exhaustion.
• Incorrect initialization: Pointer is uninitialized or initialized with an incorrect address, causing undefined behavior upon dereferencing.
• Dereferencing null pointer: Attempting to access memory at address nullptr. Leads to segmentation fault/exception.
• Pointer arithmetic errors: Going out of bounds of allocated memory when using increment/decrement or offset.
• Incorrect pointer type casting: Casting a pointer of one type to another when types are incompatible or data structures do not match.
• Double free: Attempting to free the same memory block more than once. Leads to undefined behavior, potentially corrupting internal memory manager structures.
• Lack of ownership: Unclear which part of the code is responsible for freeing allocated memory.
• Unsafe string functions: Functions like strcpy, strcat do not check buffer boundaries, which can lead to buffer overflow and vulnerabilities.

To mitigate these issues in C++, smart pointers (unique_ptr, shared_ptr, weak_ptr), RAII, and standard library containers (vectors, lists) are used.

// Example of a dangling pointer
int* ptr = new int(10);
// ... use ptr
delete ptr; // freed memory
// ptr still points to freed memory
// int value = *ptr; // Undefined behavior

// Example of a memory leak
void create_leak() {
    int* leak_ptr = new int(20);
    // Pointer leak_ptr goes out of scope without delete
} // Memory allocated by new is not freed