Re: C2124 is most disrespectful of IEEE floating point arithmetic
"Victor Bazarov" <v.Abazarov@comAcast.net> wrote in message
news:ed1db9$rii$1@news.datemas.de
John Carson wrote:
[..] By
5.19/3
"An arithmetic constant expression shall satisfy the requirements for
an integral constant expression, except that
- floating literals need not be cast to integral or enumeration type,
- conversions to floating point types are permitted."
Thus 1.0f/0.0f is an "arithmetic constant expression". Is this the
same as a "constant expression" that would make the program
ill-formed. Section 5.19/2 appears to give the answer:
"Other expressions [including arithmetic constant expressions] are
considered constant-expressions only for the purpose of non-local
static object initialization (3.6.2)."
In
int main()
{
float f (1.0f/0.0f);
}
f is not a non-local static object, so 1.0f/0.0f is not a "constant
expression" and therefore the program is *not* ill-formed.
By this reasoning, however,
float f (1.0f/0.0f);
int main()
{
}
is ill-formed. Comeau, however, compiles this program too, so I am
still puzzled.
Compilers have bugs. Undefined behaviour is just that, undefined.
Combine the two and you can have any behaviour either due to compiler
vendor's intent or dispite it, and there is nothing that one could
deduce about code correctness by looking how compilers behave. The
only true sources of information are the Standard and time.
In principle, yes. In practice, whether Comeau compiles something is
generally a much better indication of whether it is conformant code that
whether, after studying the Standard, I think it is conformant code. I
routinely use Comeau to tell me with at least 99% accuracy whether or not
something is standard compliant.
If we think that either VC++ or Comeau C++ misbehave, we need to talk
to the folks who make them. But even then, considering the situation
at hand, you are most likely simply get the response "the behaviour
[of the division by zero] is undefined by the Standard, so we decided
to define it as this..." followed by what you already know, Comeau
lets it slide, VC++ complains.
VC++ is known to be overprotective. I don't know about Comeau in that
regard. It is very likely that if you do get a response from VC++
team, it's going to be one of those "since the 1.f/0.f expression has
undefined behaviour in run-time, we diagnose it for you and protect
you from doing the wrong thing". Then you ask "what about a/b when
b is initialised to 0.f", and you'll hear "well, we're not gods, you
know".
As to the fact that Comeau compiles what seems to be an ill-formed
program, the answer is simple: compilers are allowed to do that. It
might be required to give a diagnostic, but I'm too lazy to find that
out.
Let me save you the trouble. From section 1.4/1-2 of the standard:
"1. The set of diagnosable rules consists of all syntactic and semantic
rules in this International Standard
except for those rules containing an explicit notation that "no diagnostic
is required" or which are described
as resulting in "undefined behavior."
2. Although this International Standard states only requirements on C++
implementations, those requirements
are often easier to understand if they are phrased as requirements on
programs, parts of programs, or execution
of programs. Such requirements have the following meaning:
- If a program contains no violations of the rules in this International
Standard, a conforming implementation
shall, within its resource limits, accept and correctly execute [fn.
"Correct execution" can include undefined behavior, depending on the data
being processed; see 1.3 and 1.9.] that program.
- If a program contains a violation of any diagnosable rule, a conforming
implementation shall issue at
least one diagnostic message, except that
- If a program contains a violation of a rule for which no diagnostic is
required, this International Standard
places no requirement on implementations with respect to that program."
Thus if it is correct that the program
float f (1.0f/0.0f);
int main()
{
}
is ill-formed, then Comeau is obliged to give a diagnostic. However,
consistent with what I said earlier, I suspect that I have got some subtle
point wrong and the code is *not* ill-formed.
As for VC++, my reading of 1. and the first dashed item under 2. says that
the mere fact that behaviour is undefined does not allow a conforming
implementation to fail to compile it. Since, on my reading
int main()
{
float f (1.0f/0.0f);
}
only involves undefined behaviour and is not ill-formed, VC++ should compile
it.
Of course, I could be wrong.
--
John Carson