So an array sub that is greater than the adressed spaces can pick up data from areas outide the program?

Yes, if an array subscript (index) exceeds the allocated bounds of the array, it leads to **out-of-bounds memory access**, which can cause **undefined behavior** in languages like C and C++.

### **What Happens?**
1. **Accessing Adjacent Memory:**
– The program may read or write data beyond the array, potentially accessing adjacent variables, stack data, or even memory mapped for other processes (though modern OS protections mitigate this).

2. **Segmentation Fault:**
– If the out-of-bounds access hits a protected memory region, the program crashes with a segmentation fault.

3. **Memory Corruption:**
– Writing to an out-of-bounds index may overwrite other critical program data, leading to unpredictable behavior.

4. **Exploits and Security Risks:**
– Attackers can manipulate such vulnerabilities (buffer overflows) to execute arbitrary code, especially in systems without strict memory protections.

### **Example in C++**
“`cpp
#include
using namespace std;

int main() {
int arr[5] = {1, 2, 3, 4, 5};
cout << arr[10] << endl; // Out-of-bounds read, could return garbage or crash.
arr[10] = 42; // Out-of-bounds write, may corrupt memory.
return 0;
}
“`
### **How to Prevent This?**
– **Use bounds checking:**
– In C++, use `std::vector` or `std::array`, which have `.at(index)` that throws an exception on out-of-bounds access.
– In Python and Java, arrays/lists automatically check bounds and throw errors if exceeded.
– **Enable compiler warnings:**
– Use `-fsanitize=address` (GCC/Clang) or `/GS` (MSVC) to catch out-of-bounds errors.
– **Use memory-safe languages:**
– Rust, Java, and Python prevent such access with built-in bounds checking.

Would you like a more detailed example on handling this safely?