Considering the following code, is it safe to do pointer arithmetic on nullptr?
I assume adding any offsets to a nullptr results in another nullptr, so far MSVC produce results as I expected, however I am a bit unsure about whether using nullptr like this is safe:
float * x = nullptr;
float * y = x + 31; // I assume y is a nullptr after this assigment
if (y != nullptr)
{
/* do something */
}
You didn't define what "safe" means to you, but regardless, the code you propose has undefined behaviour. Pointer arithmetic is only allowed on pointer values that point into an array object, or perhaps to one-past-the-end of an array. (Non-array objects are considered an array of one element for the purpose of this rule.)
Since the null pointer is never the address of an object or one past an object, your code can never have well-defined behaviour.
int* a; a++; is UB even if I dont dereference the pointer? Can you give a reference for that?
if checks in your code". In short, UB can lead to time travel bugs, where code far away from the UB behaves in ways that do not match the code you wrote.int* a;a++ is UB until 1 hour agoIs it safe to do pointer arithmetic on
nullptr?
C++ defines two kind of operations on nullptr. For:
float *x = nullptr;
float *y = nullptr;
x +/- 0 = x
x - y = 0 (x and y have the same type)
You cannot make an assumption about what is not defined, so you shouldn't do it.
x==y. Seems trivial, but it really means that there is just one null pointer value.
x + 0: data() + size() is always valid for a vector even if it's empty in which case data() may or may not return null pointer.Addign 0 to nullptr has well defined behavior and gives you nullptr back.
Adding anything else to nullptr has undefined behavior.
[expr.add]/4 has
When an expression J that has integral type is added to or subtracted from an expression P of pointer type, the result has the type of P.
- If P evaluates to a null pointer value and J evaluates to 0, the result is a null pointer value.
- Otherwise, if P points to an array element i of an array object x with n elements ([dcl.array]), the expressions P + J and J + P (where J has the value j) point to the (possibly-hypothetical) array element i+j of x if 0≤i+j≤n and the expression P - J points to the (possibly-hypothetical) array element i−j of x if 0≤i−j≤n.
- Otherwise, the behavior is undefined.
The first bullet point covers adding zero, the second deals with having an array, and the last bullet covers everything else.
Since we never have an array we can ignore the second bullet and just deal with the first and third. That gives us adding zero is defined behavior and adding any other value has undefined behavior.
... is it safe to do pointer arithmetic on nullptr?
No, arithmetic on the nullptr is not well defined since it is itself not a pointer type (but conversions to NULL values of all pointer types exist).
std::nullptr_tis the type of the null pointer literal,nullptr. It is a distinct type that is not itself a pointer type or a pointer to member type.
In general, arbitrary pointer arithmetic (even on the NULL value) is almost certainly going to cause problems - you didn't allocate that memory - it is not yours to attempt to read or write to.
For comparison purposes (e.g. one past the end), you will be fine, but otherwise the code you have will result in undefined behaviour.
For further reading, see Wikipedia on undefined behavior.
No, adding an offset to a nullptr does not result in a nullptr. This is undefined behavior.
float* a = nullptr; assert(a==nullptr); a++; assert(a!=nullptr);. Adding something tonullptrdoesn't result innullptrwith these compiles. I don't know if it is UB.31. That's not the null pointer. The compiler is allowed to do exactly this. If null pointer + offset was defined to be the null pointer, the compiler would have to add some conditional jump there. Since the committee cares about efficiency, the standard does not mandate what happens when you add a non-zero offset to the null pointer.