Re: iterator error
On Apr 6, 1:59 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
James Kanze wrote:
On Apr 6, 3:02 am, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
=C0=D6=C0=D6=B4=F3=CC=EC=CA=A6 wrote:
windows xp, visual studio 2005
---------------------------------------------------------------------=
-------------------------------------------------------------
#include <iostream>
#include <map>
using namespace std;
int main()
{
map<int, int>::iterator it = 0;
if( it != 0 ) //break point,
this is an run time error?
cout<<"ok!";
}
---------------------------------------------------------------------=
-------------------------------------------------------------
why it can be assign "0", but can't compare with "0"?
The iterator type in 'map' is implementation-defined. What
it means to initialise it with (int)0 is implementation-defined.
Why operator != (int)0 doesn't work is (you guessed it!)
implementation-defined.
It's not even implementation-defined, it's undefined.
Is it explicitly undefined (as in dereferencing a null pointer)?
Yes. The standard says that just about anything you do with the
library that isn't conform results in undefined behavior. There
are practically no requirements that e.g. a diagnostic be
emitted.
In practice, there's a lot of undefined behavior that will
either work, or result in a diagnostic, even if the standard
says it's undefined. The line `cout<<"ok!";' in the above
program, for example, is undefined behavior, since the code
fails to include the necessary header (<ostream>). But I can't
conceive of an implementation in which it either worked, or
failed to compile.
All I can see in the standard is that 'iterator' type in 'std::map'
is implementation-defined.
The type is implementation defined; most typically, it will be a
nested class or a typedef. The operations which it must support
are defined, however. And any attempt to do anything else with
it is undefined behavior.
Is it not conceivable that the type
might actually define comparison with 0?
The implementation might define it. That's one legal way of
handling undefined behavior. In the case of `cout<<"ok!"', for
example, both the g++ and the Dinkumware library define it; g++,
at least, has explicitly added code in <iostream> to make it
defined. And on my system, dereferencing a null pointer is
defined---the system guarantees an immediate core dump. But the
standard still says it is undefined, and I've used systems where
it could do some very strange things.
--
James Kanze (Gabi Software) email: james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34