当指针太大时会发生什么？

Question

What happens, in C++ or C, if a pointer is set to a value so high that it goes out of the bounds of memory? Here's some code that would do such a thing:

int* ptr = 0;
while (true) {
    ptr += 1; // eventually this will go out of bounds of the memory ... unless there is an overflow.
    *ptr = 10; // just give it a value, why not?
}

What happens? Does the pointer -- when it gets out of the bounds of, let's say a 16 byte memory -- just flip from 0xF to 0x0? Does it keep counting up and the *ptr = 10; line crashes the computer?

I'm not stupid enough to try, but I am very curious.

Answer 1

Undefined behavior.

In fact, incrementing a pointer so it points to a location more than one element past the end of the object to which it originally pointed causes undefined behavior. (You're permitted to construct a pointer just past the end of an object, but not beyond that.) (The object in question is an array, with a non-array object being treated as an array with one element.)

Which means that the language standard says nothing about what can happen. It might "work", it might crash your program, it might result in any symptom that your program is capable of producing.

In practice, the behavior is likely to vary from one system to another. It's likely that incrementing a pointer will do the same thing as incrementing an unsigned integer: update the value without causing any visible problems. If you try to dereference the pointer, the results depend on how your system manages memory.

Bottom line: Undefined behavior is undefined.

Answer 2

Accessing memory outside of what is allocated to you (by new or malloc etc.) is undefined behavior in C++, so don't expect anything to go well.

In practice, incrementing a pointer outside of the physical limits is defined by the platform, for most platforms, it will eventually roll over; accessing it may result in a crash.

For most modern OSes, attempting to read or write memory outside of what the process is allocated with result in an access violation or segmentation fault.

Answer 3

Pointers are only valid to an object or "1 pass".

int x;
int *p = &x;
p++;
p++; // invalid
int y[5];
p = &y[4];
p = &y[5];
p = &y[6]; // invalid

Pointers may be assigned a null pointer value;

p = NULL;

Pointers can refer to a funciton.

That's it. Assigning a pointer to some other value is undefined behavior (UB) such as:

int* ptr = 0;
ptr += 1;  // UB  (NULL is not a pointer to a valid object, so "1 pass" is UB)

Answer 4

The C/C++ language is not defined for an existing system/machine, but an abstract black box (although it does not ignore reality). You are asking for undefined behavior (some existing systems/machines may do what you expect)

Answer 5

On the common systems I'm aware of (which would be mainly/solely my system), pointers behave very much like unsigned long s:

int main(){
    char* p = NULL;
    printf("%p\n", p);
    printf("%p\n", --p);
}

outputs:

(nil)
0xffffffffffffffff

But I guess all kinds of exotic stuff could happen, theoretically.

Answer 6

IMO, your pointer won't have any problem, there's nothing to happened if you just save the pointer, but when you try to dereference/access it i'm sure your code would ended up in access violation and crash your program. or if it's a valid pointer, it would modify something else data, possibly modified another variable content tho'