Re: Safe reuse of allocated storage
Nikolay Ivchenkov wrote:
Consider the following example:
#include <memory>
struct X
{
X(int &r) : ref(r) {}
int &ref;
};
int m;
int n;
int main()
{
std::allocator<X> a;
X *p = a.allocate(1);
a.construct(p, m);
p->ref = 1; // well-defined
a.destroy(p);
a.construct(p, n);
p->ref = 1; // leads to undefined behavior
a.destroy(p);
a.deallocate(p, 1);
}
This program sequentially creates two objects of type X on the same
memory location. The object of type X created first I will call "the
first object" and the object of type X created second I will call "the
second object".
According to N3225 - 3.8/7:
------------------------------------------
If, after the lifetime of an object has ended and before the storage
which the object occupied is reused or released, a new object is
created at the storage location which the original object occupied, a
pointer that pointed to the original object, a reference that referred
to the original object, or the name of the original object will
automatically refer to the new object and, once the lifetime of the
new object has started, can be used to manipulate the new object, if:
- the storage for the new object exactly overlays the storage location
which the original object occupied, and
- the new object is of the same type as the original object (ignoring
the top-level cv-qualifiers), and
- the type of the original object is not const-qualified, and, if a
class type, does not contain any non-static data member whose type is
const-qualified or a reference type, and
- the original object was a most derived object (1.8) of type T and
the new object is a most derived object of type T (that is, they are
not base class subobjects).
------------------------------------------
According to N3225 - 3.9.2/3:
------------------------------------------
If an object of type T is located at an address A, a pointer of type
cv T* whose value is the address A is said to point to that object,
regardless of how the value was obtained.
------------------------------------------
I have a question about these two texts. Why do pointers need to explicitly
be updated to point to the second object by 3.8/7, when 3.9.2/3 already
says
that the pointer will point to the second object? Why is 3.8/7 not
redundant
in the case of pointers? Let me make an example
int a[2][1];
int *p = a[0] + 1;
*p = 0;
This "p" is a past-the-end pointer for a[0], but it happens to "point to"
the integer at a[1][0]. Does the spec say somewhere that "p" is allowed to
assume to point at garbage, instead of the object of type "int" located at
&a[1][0] ?
If my code is valid, I can't understand why your code would be invalid.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]