Re: STL map question : directed to stl map expert(s)....
Alf P. Steinbach wrote:
From a practical point of view, some processors may have address
registers that trap on loads of certain invalid pointer values. This
has been discussed in [clc++m] before. E.g., first hit in Google, <url:
http://groups.google.com/group/comp.lang.c++.moderated/browse_thread/thread/bfa690ee78a1ed3b/aace2398221b7a13>.
Wow. Thanks for the link. My brain has now thoroughly exploded! Also thanks
to the other seasoned posters who have patiently corrected my uninformed
comments thus far. ;)
I'd like to pick up on a point from that earlier thread which is still kinda
related to this one (albeit quite loosely). There's something from that
discussion which now bothers me (taken from the post at
http://preview.tinyurl.com/36vqj9 ):
The pointer has a value, which is (or rather may be) an address
Roughly speaking, we can consider this value as being in one
of four categories:
1. the address of an object, or the raw memory which will or has
held an object,
2. the address one behind the last object in an array -- for this
use, a scalar object is considered to be an array of one,
3. a null pointer, or
4. an invalid pointer.
What you can do with a pointer depends on which category its value is
in. You can only dereference pointers in category 1. You can only
compare pointers for inequality if they are in category 1 or 2, and only
then if they both point into the same array. You can only access the
value of the pointer (the address) if the pointer is in category 1, 2 or
3. You can take the address of the pointer, or assign something to it,
in all four categories."
There were some minor clarifications of some of these points in the
discussions that followed, but this will suffice for what I want to ask
here. Firstly though, I'd appreciate it if someone could point me at the
part of the standard which talks about comparing pointers for inequality
being valid only if they both point into the same array.
The above-quoted comments get interesting if you have a std::map where the
key_type is a pointer. The default comparison for such a map is
less<key_type>, which for a pointer has default implementation a < b. Now
I'm wondering under what circumstances such comparisons are technically
legal. I'd be interested in which of the following cases are valid and
which are not:
int a[2] = { 6, 7 }
int b = 1;
int c = 2;
std::map<int*,int> myMap1;
myMap1[&a[0]] = 15; // (1)
myMap1[&a[1]] = 16; // (2)
myMap1[&b] = 17; // (3)
std::map<int*,int> myMap2;
myMap[&b] = 25; // (4)
myMap[&c] = 26; // (5)
Will any of (1)-(5) lead to undefined behavior? From what I've understood of
the thread quoted, there would seem to be a good case for (3) and (5) to be
undefined behavior, but if this is true then this would seem to be a
surprising result (to me at least).
--
Craig Scott
Computational Modeling, CSIRO (CMIS)
Melbourne, Australia
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]