why have both "." and "->" ?

[raj]

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

Raj

[Kapt. Boogschutter]

"raj" <ra******@hotmail.com> schreef in bericht
news:d7**************************@posting.google.c om...

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.
Raj

There is a difference I believe that xxxx->yyyy is used if xxxx is a pointer
to an object/class and xxxx.yyyyy if xxxx is the object/classs

[Marco Wahl]

> class A{

f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

IMHO it's simply convenience.

Bye, Marco

[Russell Hanneken]

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both
operators.

The second form involves more typing and requires more effort to read.

--
Russell Hanneken
eu*******@cbobk.pbz
Use ROT13 to decode my email address.

[Richard Herring]

In message <WO*****************@newsread1.news.pas.earthlink. net>,
Russell Hanneken <[e-mail]> writes

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both
operators.

The second form involves more typing and requires more effort to read.

And they might have different effects if aa is of user-defined type.
Usually, operator->() returns (something that behaves like) a pointer;
operator*() returns a reference. Either or both might be some kind of
proxy object, not the object that aa ultimately "points" at. There's no
guarantee that they indirect to the same thing, or even that they are
both defined.

--
Richard Herring

[Peter Ammon]

raj wrote:

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

Raj

The reason is obvious: for compatibility with C.

--
Pull out a splinter to reply.

[Mike Wahler]

"raj" <ra******@hotmail.com> wrote in message
news:d7**************************@posting.google.c om...

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both

operators.

The -> operator is not technically necessary, it's just
a 'shorthand' notation for (*).

Use whichever you like, but keep in mind that ->
is typically considered more 'idomatic' (i.e.
most coders will recognize it, and often makes
reading code faster.)

-Mike

[tom_usenet]

On 23 Jun 2004 08:48:27 -0700, ra******@hotmail.com (raj) wrote:

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

You can separately overload operator-> and unary operator* for user
defined types. That's the only difference really, but aa->f() is much
nicer to read.

Tom
--
C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[jeffc]

"raj" <ra******@hotmail.com> wrote in message
news:d7**************************@posting.google.c om...

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both

operators.

The second is pretty awkward, but anyway, what would you do with this?
A aa;

[jeffc]

"jeffc" <no****@nowhere.com> wrote in message
news:40********@news1.prserv.net...

The second is pretty awkward, but anyway, what would you do with this?
A aa;

Never mind, didn't read your question quite right. You are not implying
that we don't need ".".

[Default User]

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

The short answer to your question is, "because C did it that way." C++
was not about to redefine the usage. So why did C?

For the case above, the reply is obvious, syntactic sugar. The better
question is, why didn't C overload the . operator to work on either
struct/union objects or on pointers? For that, you'd have to ask Dennis
Ritchie. There probably is a good reason.

Brian Rodenborn

[Andrey Tarasevich]

raj wrote:

...
I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.
...

Well, any boolean function can be implemented by using logical operation
'xor' (or 'nor', or 'nand') and nothing else. Yet instead of single
'xor' we have 'and' (&&), 'or' (||) and 'not' (!) in the language. Why?
The make code easier to read. The same applies to '->' operator. In many
situations it produces more compact and easily readable code.

And it also gives us an additional overloadable operator.

--
Best regards,
Andrey Tarasevich

[JKop]

Richard Herring posted:

In message <WO*****************@newsread1.news.pas.earthlink. net>,
Russell Hanneken <[e-mail]> writes

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need
both operators.

The second form involves more typing and requires more effort to read.

And they might have different effects if aa is of user-defined type.
Usually, operator->() returns (something that behaves like) a pointer;
operator*() returns a reference. Either or both might be some kind of
proxy object, not the object that aa ultimately "points" at. There's no
guarantee that they indirect to the same thing, or even that they are
both defined.

Sounds like bullshit.

-JKop

[Ali Cehreli]

On Wed, 23 Jun 2004 11:27:08 -0700, JKop wrote:

Richard Herring posted:

In message <WO*****************@newsread1.news.pas.earthlink. net>,
Russell Hanneken <[e-mail]> writes

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need
both operators.

The second form involves more typing and requires more effort to read.

And they might have different effects if aa is of user-defined type.
Usually, operator->() returns (something that behaves like) a pointer;
operator*() returns a reference. Either or both might be some kind of
proxy object, not the object that aa ultimately "points" at. There's no
guarantee that they indirect to the same thing, or even that they are
both defined.

Sounds like bullshit.

-JKop

But it is not:

struct Type0
{
int foo() const
{
return 42;
}
};

struct Type1
{
int foo() const
{
return 7;
}
};

struct Proxy
{
Type0 type0_;
Type1 type1_;

Type0 & operator* ()
{
return type0_;
}

Type1 * operator-> ()
{
return &type1_;
}
};

#include <iostream>

int main()
{
Proxy p;
std::cout << (*p).foo() << '\n';
std::cout << p->foo() << '\n';
}

[red floyd]

JKop wrote:

Richard Herring posted:

In message <WO*****************@newsread1.news.pas.earthlink. net>,
Russell Hanneken <[e-mail]> writes

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need
both operators.

The second form involves more typing and requires more effort to read.

And they might have different effects if aa is of user-defined type.
Usually, operator->() returns (something that behaves like) a pointer;
operator*() returns a reference. Either or both might be some kind of
proxy object, not the object that aa ultimately "points" at. There's no
guarantee that they indirect to the same thing, or even that they are
both defined.

Sounds like bullshit.

-JKop

Look up "smart pointers" on google. Then tell us it's bullshit.

[JKop]

Ali Cehreli posted:

struct Type0
{
int foo() const
{
return 42;
}
};

struct Type1
{
int foo() const
{
return 7;
}
};

struct Proxy
{
Type0 type0_;
Type1 type1_;

Type0 & operator* ()
{
return type0_;
}

Type1 * operator-> ()
{
return &type1_;
}
};

#include <iostream>

int main()
{
Proxy p;
std::cout << (*p).foo() << '\n';
std::cout << p->foo() << '\n';
}

I stand corrected.

-JKop

[Victor Bazarov]

Default User wrote:

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

The short answer to your question is, "because C did it that way." C++
was not about to redefine the usage. So why did C?

For the case above, the reply is obvious, syntactic sugar. The better
question is, why didn't C overload the . operator to work on either
struct/union objects or on pointers? For that, you'd have to ask Dennis
Ritchie. There probably is a good reason.

C++ allows overloading of -> but not .

V

[JKop]

Victor Bazarov posted:

Default User wrote:

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need
both operators.

The short answer to your question is, "because C did it that way." C++
was not about to redefine the usage. So why did C?

For the case above, the reply is obvious, syntactic sugar. The better
question is, why didn't C overload the . operator to work on either
struct/union objects or on pointers? For that, you'd have to ask
Dennis Ritchie. There probably is a good reason.

C++ allows overloading of -> but not .

He refering to how one can overload * .

If one overloads both * and -> for a class, and makes them different, then
the following is no longer equal:

SomeClass jk;

jk->Chocolate();

(*jk).Chocolate();
-JKop

[Rob Williscroft]

Victor Bazarov wrote in
news:el******************@dfw-read.news.verio.net in comp.lang.c++:

Default User wrote:

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need
both operators.

The short answer to your question is, "because C did it that way."
C++ was not about to redefine the usage. So why did C?

For the case above, the reply is obvious, syntactic sugar. The better
question is, why didn't C overload the . operator to work on either
struct/union objects or on pointers? For that, you'd have to ask
Dennis Ritchie. There probably is a good reason.

C++ allows overloading of -> but not .

I'm guessing that Default Users's point was, that given:

struct X
{
int x;
};

struct X xx, *xp = &x;

'C' could have done this:

Have xp.x be an int * pointing to xx.x and then *xp.x would have
derefrenced it (i.e. today's xp->x), no need for (*xp).x or xp->x.

I've encontered one C compiler that actually did this, no idea
wether it was a feature or a bug :).

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Default User]

Victor Bazarov wrote:

Default User wrote:

raj wrote:

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

The short answer to your question is, "because C did it that way." C++
was not about to redefine the usage. So why did C?

For the case above, the reply is obvious, syntactic sugar. The better
question is, why didn't C overload the . operator to work on either
struct/union objects or on pointers? For that, you'd have to ask Dennis
Ritchie. There probably is a good reason.

C++ allows overloading of -> but not .

But if there was no -> operator, then there would probably be a way to
overload the . operator.

I think that's a result of having two operators, not a cause. As in the
developer(s) didn't think to themselves, "It'd be greate to get rid of
that unnecessary -> but let's keep it so we don't have to allow
overloading the . operator."

The reason there's two is that C did it that way. As a consequence, C++
could take advantage by allowing overloads for one but not the other.

Brian Rodenborn

[Howard]

"Kapt. Boogschutter" <so*****@nobody.com> wrote in message
news:cb**********@news5.tilbu1.nb.home.nl...

"raj" <ra******@hotmail.com> schreef in bericht
news:d7**************************@posting.google.c om...

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both operators.

Raj

There is a difference I believe that xxxx->yyyy is used if xxxx is a

pointer to an object/class and xxxx.yyyyy if xxxx is the object/classs

That's true, but look at the question again. The poster explicitly used
(*aa).f(), and that's using a de-referenced pointer, which is the same thing
as your xxxx.yyyy example.

His question was why the "aa->f()" form is needed if you can accomplish it
using "(*aa).f()".

I would guess it's a convenience. It's sure easier to type, in my opinion!

-Howard

[Steven T. Hatton]

raj wrote:

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both
operators.

Raj

After reviewing some of the replies to your question, you may be asking "Why
are people in this news group so obnoxious, condescending, and rude?". I
certainly am asking, but I can't answer that question.

--
STH
Hatton's Law: "There is only One inviolable Law"
KDevelop: http://www.kdevelop.org SuSE: http://www.suse.com
Mozilla: http://www.mozilla.org

[Steven T. Hatton]

Mike Wahler wrote:

"raj" <ra******@hotmail.com> wrote in message
news:d7**************************@posting.google.c om...

I used to remember why c++ needed both ?
Could somebody help me here ?

For example

class A{
f();
};

A* aa;

You could do either "aa->f()" or "(*aa).f()". So why does C++ need both

operators.

The -> operator is not technically necessary, it's just
a 'shorthand' notation for (*).

Use whichever you like, but keep in mind that ->
is typically considered more 'idomatic' (i.e.
most coders will recognize it, and often makes
reading code faster.)

-Mike

Now that's an answer worth providing.
--
STH
Hatton's Law: "There is only One inviolable Law"
KDevelop: http://www.kdevelop.org SuSE: http://www.suse.com
Mozilla: http://www.mozilla.org

[a]

"Ali Cehreli" <ac******@yahoo.com> wrote in message
news:pa*********************************@yahoo.com ...

On Wed, 23 Jun 2004 11:27:08 -0700, JKop wrote:

Richard Herring posted:

In message <WO*****************@newsread1.news.pas.earthlink. net>,
Russell Hanneken <[e-mail]> writes
raj wrote:
>
> You could do either "aa->f()" or "(*aa).f()". So why does C++ need
> both operators.

The second form involves more typing and requires more effort to read.

And they might have different effects if aa is of user-defined type.
Usually, operator->() returns (something that behaves like) a pointer;
operator*() returns a reference. Either or both might be some kind of
proxy object, not the object that aa ultimately "points" at. There's no
guarantee that they indirect to the same thing, or even that they are
both defined.

Sounds like bullshit.

-JKop

But it is not:

struct Type0
{
int foo() const
{
return 42;
}
};

struct Type1
{
int foo() const
{
return 7;
}
};

struct Proxy
{
Type0 type0_;
Type1 type1_;

Type0 & operator* ()
{
return type0_;
}

Type1 * operator-> ()
{
return &type1_;
}
};

#include <iostream>

int main()
{
Proxy p;
std::cout << (*p).foo() << '\n';
std::cout << p->foo() << '\n';
}

Thats not the same behavior the original poster was asking about. Of course
if you overload the operators to do different things they will behave
differently.