Can any explain me the arrow operator in c++.thanx

a->b is the same thing as (*a).b

Or if you would like a slightly more elaborate explaination:
If you have a pointer to a structure, you cannot access its elements with the normal dot operator, you must use the -> operator. For example:

int main() {
struct some_struct a;
struct some_struct *b;

b=&a;
a.some_element = 0; /* Correct */
a->some_element = 0; /* Incorrect, a is not a pointer */
b.some_element = 0; /* Incorrect, b is a pointer */
b->some_element = 0; /* Correct */

return 0;
}

I hope that code's correct .. I'm completely exhausted at the moment.

Or like Psion said, if you actually reference the pointer data ie (*b), then you can use the dot operator.

A pointer is a variable that points to the address of where something is at. So if you did:

int *p;
cout << p;

it would print the address of where the value of p is, not the actual value. In order to print out the value of p, you would have to dereference it with the * operator:

cout << *p;

Now, with a struct (or class), you usually can do this:

struct
{
} yo;

yo.whateva

to get to the variable and functions inside, since yo is a variable with the actual value of the struct. If you did:

struct
{
} *ScaryGuyIsASexGod;

then you couldnt do:

ScaryGuyIsASexGod.something

cause you would be using the address of the struct, and that would just suck. So you have t dereference it:

(*ScaryGuyIsASexGod).something

But instead of doing that, do that shortcut:

ScaryGuyIsASexGod->something

which does the dereferencing for you, but is slower.

"which does the dereferencing for you, but is slower."

Uhm... actually both (should) result in the same code.

Exactly, both are the same things that are done in different ways(???), but there is no big difference in the time taken to accomplish it.

You need -> because * as a lower precendence than ..

You don't need -> at all. Like in my first reply in this thread, a->b is DEFINED AS (*a).b. They WILL produce identical code in any non-bizarre compiler.

Well, then I'll correct my response: -> exists because * has a lower precendence than ., and -> makes your code more readable than (*). so you should use it.../me wonders why the hell he still uses a language that has its origins as a set of assembler macros for an ancient PDP

Couldnt said it gooder myself, -> is more readable than (*)., just that it's slower.

Why would it be slower? Are you talking about at compile or run time? Surely, if it is generating the same code, then there is no difference at runtime, and I can't imagine that parsing -> would be any more difficult than parsing (*).

There is absolutely no different between the two notations. -> is merely "syntatic sugar" for (*pointer).member...