On 06/07/2010 09:38 AM, pem wrote:
I am not familar with both c++ and compiler implementation, donot konw
why the results are differnt for gcc and clang. Anyone could help and
explain this difference for me?
First of all, this would be a question for gcc-h...@gcc.gnu.org. This
mailing list is for development _of_ gcc, not _with_ gcc.
Your question is answered by the documentation of -Wsequence-point:
`-Wsequence-point'
Warn about code that may have undefined semantics because of
violations of sequence point rules in the C and C++ standards.
The C and C++ standards defines the order in which expressions in
a C/C++ program are evaluated in terms of "sequence points", which
represent a partial ordering between the execution of parts of the
program: those executed before the sequence point, and those
executed after it. These occur after the evaluation of a full
expression (one which is not part of a larger expression), after
the evaluation of the first operand of a `&&', `||', `? :' or `,'
(comma) operator, before a function is called (but after the
evaluation of its arguments and the expression denoting the called
function), and in certain other places. Other than as expressed
by the sequence point rules, the order of evaluation of
subexpressions of an expression is not specified. All these rules
describe only a partial order rather than a total order, since,
for example, if two functions are called within one expression
with no sequence point between them, the order in which the
functions are called is not specified. However, the standards
committee have ruled that function calls do not overlap.
It is not specified when between sequence points modifications to
the values of objects take effect. Programs whose behavior
depends on this have undefined behavior; the C and C++ standards
specify that "Between the previous and next sequence point an
object shall have its stored value modified at most once by the
evaluation of an expression. Furthermore, the prior value shall
be read only to determine the value to be stored.". If a program
breaks these rules, the results on any particular implementation
are entirely unpredictable.
Examples of code with undefined behavior are `a = a++;', `a[n] =
b[n++]' and `a[i++] = i;'. Some more complicated cases are not
diagnosed by this option, and it may give an occasional false
positive result, but in general it has been found fairly effective
at detecting this sort of problem in programs.
The standard is worded confusingly, therefore there is some debate
over the precise meaning of the sequence point rules in subtle
cases. Links to discussions of the problem, including proposed
formal definitions, may be found on the GCC readings page, at
`http://gcc.gnu.org/readings.html'.
This warning is enabled by `-Wall' for C and C++.
In general, I suggest that you always use the -Wall option, so that you
will get warnings for dobious code such as the one you pointed out.
Paolo
