What is "->" in Objective C?

I've seen this operator pop up quite a few times in example code in "Learn Objective C on the Mac."

I believe it's an operator in the C language which Objective C inherits. I tried Googling and searching Stack Overflow and oddly nothing came up.

Does i开发者_如何学运维t have an English name?

It has to do with structures.

When we have a struct available locally on the stack, we access its members with the . operator. For example:

CGPoint p = CGPointMake(42,42);
NSLog(@"%f", p.x);

However, if we instead have a pointer to a structure, we have to use the -> operator:

CGPoint *p = malloc(1*sizeof(CGPoint));
p->x = 42.0f;
NSLog(@"%f", p->x);
free(p);

-> is not specific to Objective-C. It's a C operator.

Now that's cleared, it's the member access operator, equivalent to a pointer dereference and then using the dot operator on the result.

Say you had a struct like this:

typedef struct Person {
   char *name;
} Person;

Person *jacob = malloc(1*sizeof(Person));

So this statement:

jacob->name = "Jacob";

Is equivalent to this statement:

(*jacob).name = "Jacob";

Of course, don't forget the free:

free(jacob); 

In C

a->b

is a shortcut for

(*a).b

which is for dereferencing of members of a struct that is pointed to.

This is useful, because of . binds stronger than the dereferencing operator * . So by using -> you avoid having to use these ugly parentheses.

It's a member selection (or access) equivalent to a pointer de-reference (as pointed out in comments)

a->member is equivalent to (*a).member in C/C++

The same thing that it means in C. It can be used to access the instance variables of objects directly, but generally this is not the best practice. The dot notation you're referring to is a property, not the usual C dot notation.

It's the "indirect member access operator". It's a C operator, which both Objective-C and C++ inherited.

This

a->b

is equivalent to:

(*a).b

but is less typing. (The parens are necessary in the expanded form due to precedence of * and ..)

a->b is equivalent to (*a).b, and designates member b of the object pointed to by a.

In the C standard, it is called the "structure/union pointer operator," which isn't really the catchiest name.

It's all been said, it is a shortcut for accessing members of a struct pointer, but just a note to add that you can access ivars using the same syntax due to the way the Objective-C runtime works:

@interface Foo : NSObject {
   NSString *something;
}

/* ... SNIP ... */

NSLog(@"something = %@", foo->something); // Where foo is an instance of the Foo class

This is handy when you need to access ivars that aren't exposed by methods; specifically when you need to implement copyWithZone: on your objects.