Hargraves Gary writes:

 > May I please have a little clarification by my favourite rocket
 > scientist on: that fortran is 'not pass by reference'.

Giles has concisely summarized it.  Let me just add a few
observations.

What I meant is exactly what I said - that Fortran does not specify
pass-by-reference.  That term doesn't even appear in the standard;
it's omission is intentional.  It is true that a change in the dummy
argument will result in a change to the actual argument, but that is
not what pass-by-reference means.

Nor do most implementations strictly do pass-by-reference.  Even
implementations that purport to do it are likely to store values in
registers or assume that values haven't changed between two
references; a sufficiently strict interpretation of pass-by-reference
would disallow either of those behaviors.  But even if one doesn't
adopt quite that strict interpretation, the Fortran standard still
doesn't specify pass-by-reference.

Pass-by-reference describes an implementation mechanism.  It is one of
many valid implementation mechanisms that can achieve the effects
required by the standard.  The standard intentionally avoids
specifying implementation mechanisms so as to leave compilers freedom.
A strict specification of pass-by-reference would probably be a killer
for performance.

It is my observation that the large majority of people who say that
Fortran does pass-by-reference doen't actually know what the term
means and are just referring to the fact that changes to the dummy
argument result in changes to the actual argument.  Alas, such
misuse of terminology can be fatally misleading because it leads
people who might actually happen to know what the term means to
assume that you are telling the truth.

If you assume that argument passing is by reference, then you will
write buggy, non-conforming code.  This is not just pedantic
word-picking; buggy code like that is written all the time.  Such
code often fails when optimzers are turned on, and sometimes fails
even without optimization.  With fair regularity, I am asked to help
find code bugs that turn out to arise from assumtions of pass-by-
reference behavior.

Standard-conforming code cannot distinguish between pass-by-reference
and other valid argument passing mechanisms such as copy-in/copy-out.

 > Specifically, I would like to confirm that the default standard in
 > fortran is an effective 'pass by reference'.

No, Fortran does not specify pass-by-reference.  Nor does the word
"effective" make the statement that it does true.  The appropriate
words instead of "an effective" would be "not".  Fortran does specify
that changes in the dummy argument result in changes in the actual
argument, but that is not pass-by-reference, whether modified by
"effective" or anything else.

Sorry to seem so picky about a term, but it is a harmful term
when misused.  It causes buggy code and extra work.

--
Richard Maine                |  Good judgment comes from experience;
[log in to unmask]       |  experience comes from bad judgment.
                             |        -- Mark Twain