SomeClass *ptr = [[SomeClass alloc] initWithStrAndDate:@”Foo”];
…
ptr.str = @”Foo 2″;

looks like a direct assignment of the string “Foo 2″ to the instance variable ‘str’. However, the work is still done through the setter. This is worth noting given that using properties and dot syntax result in a call to the setter, which is not as obvious as this [ptr setStr:@"Foo 2"] (which makes it clear the setter is involved).

@interface Foo : NSObject {
NSString *str;
}
@property(assign, readwrite) NSString *str;
@end

@implementation Foo
@synthesize name = str;
- (void) test {
self.str = @”hi”; // direct assignment to variable
self.name = @”hi”; // assignment through setter
[self setName: @"hi"]; // assignment through setter
}

The @synthesize directive generates the getter and setter functions, but also declare the name of the variable for the dot syntax. Thus “name” is an alias for the getter/setter even though the member variable is “str”. This becomes more important if you use the @property(retain,…) attribute:
@property (retain,readwrite) NSString *str;
…
self.str = @”hi”; // direct assignment to variable
self.name = @”hi”; // retained through setter
So while @synthesize does generate getter/setters using the Key-Value Coding rules, the dot syntax maps directly to the @synthesize name. I find this a nice enhancement to the language.

When *not* using properties, a best practice is that getter methods are simply the name of the instance variable (i.e. name versus getName), whereas a setter method pre-pends ‘set’ to the instance variable name (i.e. setName). Therefore, calling the getter looks like this [someObject name] and calling the setter [someObject setName:@"foo"].

However, when using properties and dot syntax, the practice of pre-pending ‘set’ to the instance variable names no longer applies.

I can understand why the implementation works as it does (and your comment as well). If nothing else I point this out for those who are new to Objective-C, as I am. To understand how getters/setters work (and appreciate the value-add of properties), I started by writing my own accessors. Once making the move to use properties, it simply takes a little getting used to when you are expecting setters to have the format ‘setInstanceVar’.

foo = @”Foo”;
bar.foo = @”Foo”;

You could say that you “scope” your setting to the “thing” on the left side of the dot.

I’ve been using many languages (java, c#, ruby) and just started learning Objective C. To me this way of setting and getting methods seems more natural.