The reason the value is not retained is because self.m_database = foo; is using the property setter and will thus be compiled same as when you would call [self setM_database:foo];. Whereas when you use only m_database = foo; it is equivalent to self->m_database (notice the -> instead of the dot) which is a direct access to your instance variable. This way you can get around sending a message (which is quite expensive) when all you want is to assign your instance variable, but then you have to keep in mind that you must retain / copy and check the new value yourself if needed.

I have this function in my code

- (void)viewDidLoad {

[super viewDidLoad];

self.m_database = [Database new];
MainViewController* viewController = [MainViewController alloc];
[viewController initWithNibName:@"MainView" bundle:nil];
self.m_mainViewController = viewController;
[viewController release];
m_infoButton.bounds = CGRectMake(-25, -25, 60, 50);

[self.view insertSubview:m_mainViewController.view belowSubview:m_infoButton];
[viewController setDatabase:m_database];
}

It works fine but there is one thing I don’t understand… I can still write without “self” on the member variables but what happens is that the retain-attribute on my @property won’t apply. This is interesting to point out that “self.m_database =” is not the same as “m_database =” even though the synthesize is called m_database. This apparently means that the setter-accessor is only used when “self.” is written in front of the variable

Or have I missed something?

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.