CODEWITHSUNDEEP
c++pointerslanguage-lawyerc++17
walnut
walnut

Reputation: 22162

Are pointers to allocated memory outside object's lifetime "invalid pointer[s]" or "pointer[s] to an object"?

C++17 (draft N4659) [basic.compound]/3 says:

Every value of pointer type is one of the following:

  • a pointer to an object or function (the pointer is said to point to the object or function), or

  • a pointer past the end of an object ([expr.add]), or

  • the null pointer value ([conv.ptr]) for that type, or

  • an invalid pointer value.

To which of these categories belong pointers to allocated memory outside the lifetime of objects, specifically the values of a at // (1) through // (3) and b at // (4) in the following program?

#include<new>
#include<algorithm>

struct S {
    ~S() { /* Non-trivial destructor */ }
};

struct T {
    ~T() { /* Non-trivial destructor */ }
};

int main() {
    void* a = operator new(std::max(sizeof(S), sizeof(T)));
    // (1)
    a = new(a) S;
    static_cast<S*>(a)->~S();
    // (2)
    a = new(a) T;
    static_cast<T*>(a)->~T();
    // (3)
    operator delete(a);   

    void* b = operator new(42);
    // (4)
    operator delete(b);
}

In my understanding a pointer value becomes invalid when deallocated, not when the life time of an object ends, but if the pointer values are "pointer[s] to an object", to which object do they point?

Upvotes: 5

Views: 432

Answers (2)

curiousguy
curiousguy

Reputation: 8298

All C++ standard are an abject mess when it comes to basic runtime concept.

What is an lvalue? It needs to be able to refer to a not yet created object. (Same for pointers.)

When do not created object exist? Do they appear just before they are needed?

To me the best approach would have been to assume all object types exist everywhere in memory where they fit. Many people here told me that was insane and contradictory yet no one ever pointed to a contradiction.

Upvotes: -4

Language Lawyer
Language Lawyer

Reputation: 3567

To which of these categories belong pointers to allocated memory outside the lifetime of objects, specifically the values of a at // (1) through // (3) and b at // (4) in the following program?

Pointer values returned from allocation functions (a at // (1) and b at // (4)) are not currently specified and it is barely possible to classify them according to the taxonomy in [basic.compound]/3, see https://groups.google.com/a/isocpp.org/d/msg/std-discussion/4NQawIytVzM/eMKo2AJ9BwAJ

In my understanding a pointer value becomes invalid when deallocated, not when the life time of an object ends, but if the pointer values are "pointer[s] to an object", to which object do they point?

To the object they pointed to when the object was alive.

Upvotes: 2

Related Questions