Is C's -> equivalent to dot notation in Objective-C - c++

Question

I am doing Box2D programming, and heads up, I am a total noob to C++ and C. I am an Objective-C guy, and that is why it is becoming really hard for me to understand the language. Especially:
->
Basically I understand that this is used for referencing different methods or functions or variables/properties like below:
body->GetWorld()->DestroyBody(body);
So is this equivalent to dot notation in Objective-C:
// made up example
[body.world destroyBody];
or
[self destroyBody:body.world];
Or something similar? I really don't understand this. Can someone give me a heads up on what this is. Thanks!

Answer 1

I don't know Objective-C, but I can explain difference between -> and . in C and C++, hope that helps.
. is operator that allows you to access member of struct/class instance. a->b is the same as (*a).b - so it first dereferences the pointer, then accesses member of instance that the pointer was pointing to.
Also, there is a case that Luchian has mentioned - overloading of operator->() of given class. In case when class you are using does overload this operator, the behavior will be different, defined by the class - it can return virtually everything it wants.

Answer 2

I don't know much about Objective-C, but I can try to give you some help about C++: assuming that you define a class Foo in C++, with a method bar():
class Foo
{
public:
void bar();
...
};
If you allocate an instance of Foo on the stack, you use dot notation (.) to call the method bar():
Foo f;
f.bar();
If you have a pointer to an instance of Foo, you use the arrow notation (->) to call the method bar():
Foo* pf; // must point to some instance of Foo
pf->bar();
(To complicate things, there are also references, which have value syntax and pointer semantics: if you have a reference to Foo (e.g. Foo& f) you still use dot notation: f.bar();.)

Answer 3

. is used to access object members, -> is used to access members through a pointer. Usually. operator -> can be overloaded, meaning you can also use it on objects:
struct X
{
X* other;
X* operator->() {return other;}
};
X x;
x->other;
In this case, x->other doesn't reffer to x.other, but to x.other.other. :D

Answer 4

No, using . to access Objective-C properties is not the same as either -> or . to access struct and class members in C and C++.
The Objective-C property accessor works on values of type id (which is a pointer type), but uses special naming conventions to decide what it actually does. It can directly access a property data member, making it similar to -> for data member access. Or it can look up special functions for getting and/or setting the property value, in which case it's syntax sugar for a message send.
Except in the case of operator overloading in C++, -> is always the same as dereferencing a pointer and then accessing the member referred to. a->b is equivalent to (*a).b. b may be a data member for a member function, but the accessed member will have the exact name referred to in b, not some mutation of it based on any special naming convention. If b names a member function then it may be a virtual function, which has some similarities to, but is not the same as, message sends in Objective-C. b may also be an overloaded member function in C++ which has no equivalent in Objective-C.
The addition of the . syntax for accessing object properties in Objective-C violates Objective-C's design principal that new features should look new. Using #, the [] message sending syntax, and the special keywords to define Objective-C objects are examples where Objective-C previously followed this design principal.

Answer 5

This is objective-c code.
#interface Foo : NSObject
{
NSInteger _a;
}
#property (nonatomaic, assign) NSInteger a;
#end
#implement Foo
#synthesize a = _a;
#end
You know '#synthesize' phrase.
#synthesize create bellow codes.
- (NSInteger)a
{
return _a;
}
- (void)setA:(NSInteger)aa
{
return _a = aa;
}
Let's access property a.
void main()
{
Foo foo = [[Foo alloc] init];
foo.a = 1;
}
Must assigned foo.a as 1.
But compiler call as bellow.
void main()
{
Foo foo = [[Foo alloc] init];
[foo setA:1];
}
foo.a = 1 and [foo setA:1] is same.
foo.a = 1 calls [foo setA:1].
Bellow, Written in C.
class Foo
{
private:
int _a;
public:
int getA();
void setA(const int aa);
};
int Foo::getA()
{
return _a;
}
void Foo::setA(const int aa)
{
_a = aa;
}
// local allocation example.
void main()
{
Foo foo;
foo.setA(1);
}
// Heap allocation example.
void main()
{
Foo *foo = new Foo();
foo->setA(1);
delete foo;
}
// Pointer (like object objectve-c).
void main()
{
Foo foo1;
foo1.setA(1);
Foo *foo2 = &foo1;
foo2->setA(2);
printf("result>>> %d, %d", foo1.a, foo2->a);
}
result>>> 2, 2
foo1.a and foo2->a is 2 also.
Objectve-C example bellow.
void main()
{
Foo *foo1 = [[Foo alloc] init];
foo1.a = 1;
Foo *foo2 = foo1;
foo2.a = 2;
NSLog(#"result>>> %d, %d", foo1.a, foo2.a);
}
result>>> 2, 2
Have a good day.
Thank you.