Re: Revistiing using return value as reference
On Jan 11, 8:29 pm, johanatan <johana...@gmail.com> wrote:
On Dec 31 2007, 10:17 pm, Kira Yamato <kira...@earthlink.net> wrote:
On 2007-12-31 21:36:09 -0500, johanatan <johana...@gmail.com> said:
[...]
The 'historical' understanding I had was certainly somewhat fabricated=
and falsely
extrapolated, but I think we all agree that the abstract notions of
ptrs, references, and aliases are essentially the same and could
probably offer examples of lots of different languages where this or
that aspect is this or that way. That doesn't change the fact that =
I
can still *think* of them in the abstract as essentially equivalent
concepts. :-)
Comment like this is prime example of what has become known as "truthine=
ss."
http://en.wikipedia.org/wiki/Truthiness
--
Well, if you want to get that personal, I guess I'll continue
defending myself (though I do not really need to). I highly suspect
that everyone does just this. No one has the time to exhaustively
research each and every detail of their view of the world (let alone
the histories of those views). So, we extrapolate and fill in the gaps
with somewhat speculative information. Are you saying you don't do
the same?
And, furthermore, my views actually were not all that historically
incorrect. If you want, we can get back to the original discussion.
I still do not accept that references are merely 'aliases'. If
anything, the word alias is just as flawed as pointer. A reference is
a reference. I think that's the point that people are drive home.
You have to look at the C++ standard and look at how it defines
'reference.'
Take these two examples:
int x;
int& y;
Yes, in that case, everyone agrees. That's what feels to me like an
'alias'.
But, what about this (somewhat more complex example):
void f(int& x)
{
x = 9;
}
void g(int& y)
{
y = 7;
}
int main()
{
int x = 3;
f(g(x));
}
and really it would help to make the call stack 10 or more levels
deep. There's no way you're going to implement that without using
'pointers'. If anyone can think of such a way, please do share.
Given the close ties between C and C++, it is not unreasonable at all
to think of references as pointers. You can try to indoctrinate the
new students with this notion of 'alias', but it's going to be hard to
erase the memory of pointers from C or assembly programmers.
That's all.
Please don't bother telling me how an compiler might optimize the int
main() i just posted. Even it is not complex enough to make the
point. You must assume that g(x) and f(x) are called from many
different places in your code with many different variable instances.
And, it'd help if you imagine a call stack at least 10 levels deep
with a single reference passed through to all of them (all of which
are called from many different places with many different variable
instances). In that case, please tell me how that can be 'optimized'
in order to keep the 'alias' mental imagery alive. I would propose
that even though thinking of the reference in that case as a 'pointer'
is technically incorrect according to the C++ standard, it is still
the better mental image of the two (and is in fact, pretty much
exactly what happens in the assembly code).
I think the only way to really say what influenced the C++ reference
would be to ask the designer himself. Hypothesizing that lang X or
lang Y which had a concept of 'pointer' or 'reference' as the main
motivation for the C++ reference is overlooking the 800 lb. gorilla
(who happens to have almost the same name except for those two plus
signs) and is by anyone's account a *huge* influence. How can a
servant be greater than his master?
--Jonathan