Re: Invalid pointer values in a standard container
On Jun 28, 3:33 pm, Alan McKenney <alan_mckenn...@yahoo.com> wrote:
On Jun 27, 2:07 pm, Le Chaud Lapin <jaibudu...@gmail.com> wrote:
The question is whether the following
code involves undefined behavior,
_according_to_the_Standard_
void f
{
char *a, *b, *c, *d;
a = new char[3];
b = a + 4; // UB?
delete a;
c = a; // UB?
d = a + 4; // UB?
}
I have heard it said that even setting a
pointer variable to an invalid pointer value
may cause UB, because the hardware might
have registers which automatically dereference
a pointer when set, and the compiler might use
them. (The CDC 6600/7600/17x series had such registers)
I guess I would have to agree here. If the underlying machine auto-
dereferences assignment of pointers, then that would be an example of
where one would have to be careful with use of bogus pointer values.
However, W.R.T. the OP, there seems to be two disctinct concepts under
discussion here:
1. There is what you wrote above, whether operations yielding invalid
pointer values should be allowed.
2. There is what the OP wrote, which has to do with containers.
I say, if the standard allows operations that yield invalid pointers
values, for example, using reinterpret_cast against fudged numerical
values, then that is sufficient to ignore the question of pointers in
containers. Nothing would be wrong.
The danger here is that some programmers will take this a step further
and regard a container containing an "invalid" pointer, because the
thing that it points to is "gone", as being in a rogue state,
something I disagree with.
One could imagine a memory-mapped I/O or Flash EEPROM situation where
a series of pointers are stored in an STL container, each pointer
pointing to a region of memory that not only has not been allocated,
but does not exist physically in the system (but might later when
user inserts card).
This gets back to what I said about pointers not being the things they
point to.
Here is a example of bad habit of thinking in this manner, IMO:
unsigned int weight_measure (Elephant *elephant); // function takes
'Elephant' argument - wrong
This function does not take an Elephant argument, but a pointer to
Elephant.
Conversely, some have gotten into the habit of saying that containers
contain Elephants, when in fact, they contain pointers to Elephants.
In their minds, if the Elephant disappears, the container becomes
invalid.
IMO, a pointer to an Elephant that no longer exist is (should be)
perfectly acceptable from a language point of view. It retains its
type. And it retains a state that is appropriate for that type.
Note that it is not possible to insure that every pointer is "valid"
at all times anyway.
-Le Chaud Lapin-
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]