What is the meaning of the difference between & # 8594; and. in c / c ++?

Question

Possible duplicates:
C ++: ptr-> hello (); / * VERSUS * / (* ptr) .hello ();
Why does C have a distinction between → and also.?

I know the difference between a member operator (.) And a member using a pointer operator (->).

Why did C designers create another statement for this? Why can't the compiler figure it out on its own?

If you have always used a. Is there any case, if it is ambiguous, do you mean a member or member by a pointer?

edit: I am not looking for the syntax "(* a) .b". I ask why the designers did not allow you to use "ab" instead of "a-> b"?

Answer 1

If you have a language that is inherently intended for "portable assembler", you are not trying to hide implementation details from the user. Of course, the compiler can understand that in the expression ab , the a question is a pointer. You can? For sure? All time? In a hairy, complex code? And can you imagine the circumstance when it is not possible to quickly notice that a is a pointer, can be a problem?

Stop thinking in terms of “hard to write,” and start thinking in terms of “easy to read.” (Yes, I know. This contradicts all programmers-programmers!). You will read the code several orders of magnitude more often than you will write.

Answer 2

Do you really want the compiler to figure it out on your own? If so, then the following will evaluate the same thing (assuming p is a pointer to a structure with an element x ):

 (*p).x; px 

If dereferencing a pointer here is implicit, should it be implicit everywhere? Consider:

 int* p; int i = p; // should dereferencing be implicit here as well? 

I think that would be much more confusing than having two separate statements.

It is also useful to have two operators to keep track of how many layers of indirection you have. Of course, the operator -> not needed for this, since p->x equivalent to (*p).x , but it makes the code more understandable and understandable.

Answer 3

Yes, ambiguity arises from the ability to override both operators. The best example is generic pointers . You can use a generic pointer. and → and both have different meanings.

Using → you get access to the object pointed to by. you get access to members of the shared index.

For example:

 class MyObject { public: void myFunction() {} }; boost::shared_ptr<MyObject> ptr; ptr.use_count(); // calls use_count, which is a member of boost::shared_ptr. ptr->myFunction(); // calls MyObject::myFunction, as the operator-> is overriden 

Answer 4

C ++ allows you to override the operator -> . When you have a class of smart pointers, for example std::auto_ptr , the same variable can support as . , and -> for which you use . for access to members auto_ptr and -> for access to members the pointer that it contains.

Answer 5

(*a).b matches a->b

Answer 6

Both fo->bar and (*fo).bar do the same!

The language simply provides an operator for indirect access, namely the arrow ( -> ) and treats it as a single character.

Answer 7

The → operator is just an easier way to refer to an object method or element by its pointer, instead of using something like (* p) .member or (* p) .method.

Example:

MyClass * MyObj;

MyObj-> method (); better read and understand than (* MyObj) .method ();