C是 - >相当于Objective-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 (eg 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.