why use -> (not .) with pointers?

[Felix Kater]

Hi,

when accessing the variables in a struct: What's the reason why in C
you have -> and . instead of only . ? Are there cases in which the
compiler couldn't figure out what to do?

Felix

[lawrence.jones]

P.J. Plauger <pj*@dinkumware.com> wrote:

Could be. Early C was pretty wild and wooly.

Which makes sense as far as types are concerned since it was derived
from B, which was essentially typeless.

-Larry Jones

We don't ATTEND parties, we just CRASH 'em. -- Calvin

[Kenny McCormack]

In article <JJ******************@juliett.dax.net>,
Tydr Schnubbis <fa**@address.dude> wrote:
....

Just to make it clear, there are two issues here:

#1) s->x is a shorthand for (*s).x

#2) early compilers used the difference between s->x and s.x to know
whether to generate code using indirect or direct addressing

la************@ugs.com was stating #2 as a fact. Lew Pitcher, thinking
he instead was disputing #1, replied rather harshly. I think everyone
can see that he misread the post he replied to. They are talking about
two different, but related aspects of the C syntax.

I sometimes misread posts, too. But I still haven't had the 'pleasure'
of people supporting me even when I'm wrong. This discussion is getting
a bit childish now, which I'll be the first to admit. ;)

Meta-discussion follows.

The problem with Usenet (as with the world at large) is that 75% of the
traffic is newbies (stupidly) asserting things that are clearly wrong, such
as that (for example), . and -> mean the same thing (which was the implicit
subtext of the original post). So, we spend a lot of time correcting them.

However, with the remaining 25%, which is (or should be - but please accept
this for the sake of discussion) reasonably well-informed people saying
reasonably well-informed things, the problem is that we spend 90% of our
time convincing each other that we're not in the 75%. That the default
assumption is that we are (since most of the posters, taken as a group, are)
is what led to the above misunderstanding.

[Tydr Schnubbis]

Kenny McCormack wrote:

The problem with Usenet (as with the world at large) is that 75% of the
traffic is newbies (stupidly) asserting things that are clearly wrong, such
as that (for example), . and -> mean the same thing (which was the implicit
subtext of the original post). So, we spend a lot of time correcting them.

However, with the remaining 25%, which is (or should be - but please accept
this for the sake of discussion) reasonably well-informed people saying
reasonably well-informed things, the problem is that we spend 90% of our
time convincing each other that we're not in the 75%. That the default
assumption is that we are (since most of the posters, taken as a group, are)
is what led to the above misunderstanding.

I'm glad to get some support here. It may well be that my understanding
of the English language is inadequate. But it seems to me the original
poster understands that '.' and '->' have different meanings. It's just
that he's seen other languages that use the dot for both. Like Java,
which uses the dot notation for both reference and value semantics. But
anyway, I bet he's amused to see what he's stirred up...

[Dave Thompson]

On 1 Jul 2005 14:36:04 -0700, "Me" <an*****************@yahoo.com>
wrote:

Other languages don't have this problem because you can't
create pointers to pointers and their types are automatically
dereferenced. But these languages have an ambiguity with assignment
(assuming they're imperative languages) so they need a way to
distinguish between reseating a pointer and making a copy of a value.

Explain to me how Ada, which allows pointers to pointers, doesn't
automatically dereference, only used . (not ->), and is an imperative
language, has any ambiguity with assignment (hint: it doesn't).

I think you already explained it yourself. I said in languages that
don't allow pointers to pointers and that automatically dereference
have this ambiguity. I don't really mean ambiguity in a strict sense, I
mean it in that they need a way to distinguish between reseating a
pointer and making a copy somehow. <snip>

I think you've confused yourself with the negatives. It's if you DO
have pointer to pointer and DO automatically dereference -- in
particular, an LHS -- that you (may) have an issue, as in algol.

Ada does have pointer to pointer (under another name) and dereferences
in many cases but not an LHS.

Fortran doesn't have pointer to pointer, and dereferences the pointers
it does have (since F90) everywhere including LHS but uses a distinct
syntax for reseat. C++ dereferences references everywhere but doesn't
reseat at all.

- David.Thompson1 at worldnet.att.net