Re: How do I write directly to a memory address?

[Adam Beneschan <adam@irvine.com>]

On Feb 8, 7:36 am, Hyman Rosen <hyro...@mail.com> wrote:
> On 2/7/2011 4:00 AM, Ludovic Brenta wrote:> I recently found another bug in a C program that was caused
> > by changing the value of a "passed-by-copy" parameter. Of
>
>  > course the caller was unaffected but the algorithm inside
>  > the function was broken.
>
> In C or C++, a function parameter is an ordinary variable
> which is initialized by the an expression in the function
> call. If the parameter is not const, it may then be changed
> during the operation of the function. C has worked this way
> for something like forty years, so being surprised by this
> now seems disingenuous.
>
> There's no particular reason that a function parameter should
> not be permitted to be changed, notwithstanding that you found
> a case where doing so caused an error. One puts implementation,
> for example, is
>
>      int puts(char *s)
>      {
>          while (*s) if (putchar(*s++) == EOF) return EOF;
>          return putchar('\n');
>      }

But if C has been working this way for forty years, and its
programmers still can't get it right (as evidenced by the fact that
Ludovic found a bug), then it's arguable that the language is making
it too easy to write incorrect code and too difficult to write code
you can count on.  A two-line example such as yours doesn't count as
evidence against that; it's easy to get really short subroutines
correct.  The problems come up when you have larger routines.  And
I've run into this problem with a program I maintain, in a language
(not C) that also allows value parameters to be modified locally.
Someone has gone into it and written a statement that uses the
parameter, assuming that it's the value that the caller gave it,
without realizing that someone else had written a statement up above
that changed the parameter's value.

There's always going to be a religious war between those who want a
language that doesn't make them do extra annoying stuff and putting
annoying restrictions on their code, and those who prefer a language
that provides some degree of protection against stupid errors (not
only their own, but stupid errors made by the other programmer down
the hall who got laid off two years ago).  I'm certainly not going to
resolve the religious war here.  But since I do so much of my work
with other people's code, I do have a preference for the latter, and I
think Ada got this one right.

                                  -- Adam