Customizing an iOS app in objective-c. Not super familiar with the language, and this simple task of setting up a boolean property has taken me too long.
Can anybody offer some advice here?
Video.h
#property (nonatomic, retain) NSNumber * hasCustomThumbnail;
Video.m
#implementation Video
#dynamic hasCustomThumbnail;
#end
OtherFile referencing the video
// have tried these two an many other things...
video.hasCustomThumbnail = [NSNumber numberWithBool:NO];
video.hasCustomThumbnail = #NO;
The error I get no matter how many dozens of ways I've tried this is:
'NSInvalidArgumentException', reason: '-[Video setHasCustomThumbnail:]: unrecognized selector sent to instance 0x60c0004925c0'
Have tried many suggestions including this: Using a BOOL property
I also know the video is referenced correctly because autocomplete suggests "hasCustomThumbnail" as I start typing.
I simply cannot believe how hard OBJ-c is making this :-)
Any suggestions?
The issue is that you have declared it as #dynamic. Just remove this line from the Video.m. Xcode will automatically synthesize the getters and setters.
either of this works.
[obj setHasCustomThumbnail:[NSNumber numberWithBool:true]];
obj.hasCustomThumbnail = [NSNumber numberWithBool:true];
#dynamic just tells the compiler that the getter and setter methods
are implemented not by the class itself but somewhere else (like the
superclass or will be provided at runtime).
#synthesize will generate getter and setter methods for your property.
So when you define a property with #dynamic, either your superclass or runtime should provide the necessary getter and setter. here no one has provided anything, that is the reason it is saying the unrecognized selector sent to an instance. This error will come only if it couldn't able to find a proper method for the object. Hope this will clear your doubts.
one practical use of #dynamic is that when you inherit your class from
NSManagedObject, the core data will provide the setter and getters for
the properties.
This problem is not related to BOOL or NSNumber. It is due to your calling setIsCustomThumbnail on class Video.
Either you are doing video.isCustomThumbnail = or [video setIsCustomThumbnail:] but your class does not declare this isCustomThumbnail. From your code seems you mispelled isCustomThumbnail as hasCustomThumbnail.
So make up your mind and use single name.
Related
I have been unable to find any information on this topic and most of what I know about it has come by complete accident (and a few hours of trying to figure out why my code wasn't working). While learning objective-c most tutorials I have found make variables and properties with the same name. I don't understand the significance because it seems that the property does all the work and the variable just kind of sits there. For instance:
Test.h
#interface Test : NSObject {
int _timesPlayed, _highscore;
}
#property int timesPlayed, highscore;
// Methods and stuff
#end
Test.m
#implementation Test
#synthesize timesPlayed = _timesPlayed;
#synthesize highscore = _highscore;
// methods and stuff
#end
What I know
1) Okay so today I found out (after hours of confusion) that no matter how much changing you do to the properties highscore = 5091231 it won't change anything when you try to call [test highscore] as it will still be returning the value of _highscore which (I think) is the ivar that was set in test.h. So all changing of variables in test.m needs to be changing _highscore and not highscore. (Correct me if I'm wrong here please)
2) If I understand it correctly (I probably don't) the ivars set in test.h represent the actual memory where as the #properties are just ways to access that memory. So outside of the implementation I can't access _highscore without going through the property.
What I don't understand
Basically what I don't get about this situation is whether or not I need to use the ivars at all or if I can just use #property and #synthesize. It seems like the ivars are just extra code that don't really do anything but confuse me. Some of the most recent tuts I've seen don't seem to use ivars but then some do. So is this just a coding preference thing or is it actually important? I have tried searching through Apple's Documentation but I get rather lost in there and never seem to find what I'm looking for. Any guidance will be greatly appreciated.
You can think of the syntax for synthesizing properties as #synthesize propertyName = variableName.
This means that if you write #synthesize highscore = _highscore; a new ivar with the name _highscore will be created for you. So if you wanted to you could access the variable that the property is stored in directly by going to the _highscore variable.
Some background
Prior to some version of the compiler that I don't remember the synthesis statement didn't create the ivar. Instead it only said what variable it should use so you had to declare both the variable and the property. If you synthesized with a underscore prefix then your variable needed to have the same prefix. Now you don't have to create the variable yourself anymore, instead a variable with the variableName that you specified in the synthesis statement will be created (if you didn't already declare it yourself in which case it is just used as the backing variable of the property).
What your code is doing
You are explicitly creating one ivar called highscore when declaring the variable and then implicitly creating another ivar called _highscore when synthesizing the property. These are not the same variable so changing one of them changes nothing about the other.
Should you use variables or not?
This is really a question about preference.
Pro variables
Some people feel that the code becomes cleaner if you don't have to write self. all over the place. People also say that it is faster since it doesn't require a method call (though it is probably never ever going to have a measurable effect on your apps performance).
Pro properties
Changing the value of the property will call all the necessary KVO methods so that other classes can get notified when the value changes. By default access to properties is also atomic (cannot be accessed from more then one thread) so the property is safer to read and write to from multiple thread (this doesn't mean that the object that the property points to is thread safe, if it's an mutable array then multiple thread can still break things really bad, it will only prevent two threads from setting the property to different things).
You can just use #property and #synthesize without declaring the ivars, as you suggested. The problem above is that your #synthesize mapped the property name to a new ivar that is generated by the compiler. So, for all intents and purposes, your class definition is now:
#interface Test : NSObject {
int timesPlayed;
int highscore;
int _timesPlayed;
int _highscore;
}
...
#end
Assigning a value directly to the ivar timesPlayed will never show up if you access it via self.timesPlayed since you didn't modify the correct ivar.
You have several choices:
1 Remove the two ivars you declared in your original post and just let the #property / #synthesize dynamic duo do their thing.
2 Change your two ivars to be prefixed by an underscore '_'
3 Change your #synthesize statements to be:
#implemenation Test
#synthesize timesPlayed;
#synthesize highscore;
...
I typically just use #property and #synthenize.
#property gives the compiler and the user directions on how to use your property. weather it has a setter, what that setter is. What type of value it expects and returns. These instructions are then used by the autocomplete (and ultimately the code that will compile against the class) and by the #synthesize
#synthesize will by default create an instance variable with the same name as your property (this can get confusing)
I typically do the following
#synthesize propertyItem = _propertyItem;
this will by default create a getter and a setter and handle the autorelease as well as create the instance variable. The instance variable it uses is _propertyItem. if you want to access the instance variable you can use it as such.
_propertyItem = #"Blah";
this is a mistake tho. You should always use the getter and setter. this will let the app release and renew as needed.
self.propertyItem = #"Blah";
This is the better way to handle it. And the reason for using the = _propertyItem section of synthesize is so you cannot do the following.
propertyItem = #"Blah"; // this will not work.
it will recommend you replace it with _propertyItem. but you should use self.propertyItem instead.
I hope that information helps.
In your example, #synthesize timesPlayed = _timesPlayed; creates a new ivar called _timesPlayed and the property refers to that ivar. timesPlayed will be an entirely separate variable with no relation whatsoever to the property. If you just use #synthesize timesPlayed; then the property will refer to timesPlayed.
The purpose of the underscore convention is to make it easier to avoid accidentally assigning directly to an ivar when you want to be doing it through the property (i.e. through the synthesized setter method). However, you can still acces _timesPlayed directly if you really want to. Synthesizing a property simply auto-generates a getter and setter for the ivar.
In general you do not need to declare an ivar for a property, although there may be special cases where you would want to.
This may be an old question.. but in "modern times", #synthesize- is NOT necessary.
#interface SomeClass : NSObject
#property NSString * autoIvar;
#end
#implementation SomeClass
- (id) init { return self = super.init ? _autoIvar = #"YAY!", self : nil; }
#end
The _underscored backing ivar IS synthesized automatically... and is available within THIS class' implementation, directly (ie. without calling self / calling the automatically generated accessors).
You only need to synthesize it if you want to support subclass' ability to access the _backingIvar (without calling self), or for myriad other reasons, described elsewhere.
The following code compiles just fine - but are there any issues with it?
I couldn't find any guidelines for Objective-C that would discourage us from using the same identifier for both, properties and method names:
#interface MouseCursorHelper : NSObject
#property (nonatomic, readwrite, retain) NSCursor* rotateCursor;
+ (NSCursor*) rotateCursor;
#end
FWIW, the class is implemented as a singleton modeled after NSCursor to offer app specific cursors.
It could be a little confusing.
The property generates 2 instance methods for you:
- (NSCursor *)rotateCursor;
- (void)setRotateCursor:(NSCursor *)rotateCursor;
And you also have a class method:
+ (NSCursor *)rotateCursor;
It isn't clear from a user point of view what the class method does. Documentation would help.
There's absolutely no problem with what you are doing there at all. All you are doing is saying that both the class object and instances of the class respond to rotateCursor. That's not really conceptually different to instances of NSString responding to intValue and instances of NSNumber responding to intValue. They are just different kinds of object.
In fact, you'll find several instances of Apple doing the same thing in the Cocoa framework e.g.
[NSString class]; // Sending class to the class
[#"foo" class]; // Sending class to an instance of the class.
I have a class, BPGameEngine, with a readonly property, currCharacter. In the past, I had been assigning to the ivar directly (like _currCharacter = someCharacter;) inside BPGameEngine. In a subclass I found myself needing to write to this property, and therefore redeclared it in an anonymous category like so
#interface BPGameKitMPGameEngine()
#property (readwrite, assign) BPCharacterInstance* currCharacter;
#end
The compiler then had an error (which, bizarrely, I can't reproduce anymore, two days later), which alluded to needing an #synthesize statement, so I added #synthesize currCharacter = _currCharacter; in the subclass (BPGameKitMPEngine).
I did not add a similar anonymous category in the superclass, because I was just using the iVar directly. I then discovered that the line _currCharacter = someCharacter; which is inside a method of BPGameEngine called by BPGameKitMPEngine in a call to super ([super methodContainingAssignmentToCurCharIvar]) simply did nothing. _currCharacter showed up in the debugger, and someCharacter was not nil, but after the line was executed, _currCharacter remained nil. Bizarrely, adding a similar anonymous category in the subclass fixed the problem, as did removing the #synthesize (which no longer causes Xcode to complain of compiler errors).
The inconsistent requirement for an #synthesize seems like it must be a bug in Xcode, but the rest of this has me stumped. Can someone explain the problem with having the #synthesize in the subclass?
An auto synthesised instance variable backing a property is private to the class it is created in. Therefore you cannot (directly) extend a read-only property to read-write one in a subclass - there is no access to original instance variable.
You should get various errors, such as ones pointing out you cannot access a private instance variable from your superclass if you try this. It sounds like you may have managed to create two properties, each with their own backing variable, hence a change to one is not as a change to the other - but how you managed that in this case I've no idea.
Of course you can bypass the private access... the following should work:
#interface BPGameKitMPGameEngine ()
- (void) setCurrCharacter:(int)value;
#end
and:
- (void) setCurrCharacter:(BPCharacterInstance *)value
{
[self setValue:value forKey:#"_currCharacter"];
}
HTH
I'm not sure if I did understand you problem 100% but please do the following:
Create a new class extension file for BPGameKitMPGameEngine called Private.
Import that file (#import "BPGameKitMPGameEngine_Private.h") into BPGameKitMPGameEngine.m and BPGameKitMPEngine.m.
Remove the existing class extension code from BPGameKitMPGameEngine.
And now check if it works as you would expect.
Sorry for the kind of useless post title, but since I'm not really sure what I am doing, that was the best i could come up with.
In my header file it looks like this
#interface RootViewController : UITableViewController {
NSMutableArray *eventsArray;
}
#property (nonatomic, retain) NSMutableArray *eventsArray;
#end
This is not all the properties but i removed all but one for simplicity.
I'm doing this by following a guide from apple developer. It seems as though the guide is not totally updated since it tells me to synthesize properties, wich i should not have to anymore right?
Anyways, why is it like this? To me, a beginner at this, it seems as though I declare the property twice? Or do I do something else at the first row there?
It's like this for historical reasons, with the older compiler.
You can do this nowadays:
#interface RootViewController : UITableViewController
#property (nonatomic, retain) NSMutableArray *eventsArray;
#end
The way you have it, you are declaring an instance attribute, and then you are saying you want to automatically generate getters and setters.
Nowadays, you can just say you have a property and the compiler will automatically generate the instance attribute at compile time. It removes the apparent redundancy.
To me, a beginner at this, it seems as though I declare the property
twice? Or do I do something else at the first row there?
A property and the instance variable that backs it up (if there is one) are two different things. A property is really just a promise that the class provides certain accessor methods. So the fact that you had to declare the property and ivar separately isn't strange. However, most properties are, in fact, backed by an ivar with a related name, and writing and maintaining the two separately got to be a chore. So Apple added ivar synthesis to the compiler, so that the compiler generates an ivar for any synthesized properties for which an ivar doesn't already exist. Also, because synthesized accessors are by far the most common, and because the compiler will use any accessors that you provide even if a property is marked #synthesize, that became the default so that you no longer need the compiler directive.
Though this is somewhat a very basic question but I have some doubts still left after reading so many documents and questions on stackoverflow.com.
I want to know why to declare some instance variables as properties.
MYViewController.h
#interface MyViewController : UIViewController {
UIButton *btn;
NSString *name;
}
#property (nonatomic, retain) UIButton *btn;
#property (nonatomic, retain) NSString *name;
MyViewController.m
#implementation MyViewController
#synthesize btn;
-(void) viewDidLoad()
{
[btn setTitle:#"Hello" forState:UIControlstaeNormal]; //this is first way where there is no need to declare btn as property
[self.btn setTitle:#"Hello" forState:UIControlstaeNormal]; //this is second way where we do need to decalre btn as property as we are accessing it through self
//Setting value of name
name = #"abc"; //this is first way where there is no need to declare name as property
[self setName:#"abc"; //this is second way where we do need to declare name as property as we are accessing its aetter method through self
}
Now in the above code I wanna know when we can use the getter/setter methods of btn variable without declaring it as property then what is the need to declare it as property and which is the better way to set the value of "name".
Somewhere I read that when you want your instance variables to be accessed my other class objects then you should declare them as instance variables. Is it the only situation where we should declare them as properties.
Basically I am a little confused about in which situations to declare the instance variables as properties.
Please suggest.
Thanks in advance.
In short, you don't have to declare instance variables as properties unless you want to.
You declare a variable as a property in order to auto-generate getter and setter methods. In your property declaration you can specify how you want them set up (retain vs assign, atomic vs nonatomic). Then, the getter and setter are generated with the #synthesize directive.
So, again, there is no right or wrong way to use properties. Some people never use them, some people make every variable a property. It's really up to you.
typically, you'll use them because:
1) the property belongs in the public interface of the class
used when the class needs to expose a given method. the downside is that clients and subclasses may abuse the public interface (all objc methods are public, where visible), unless you're careful to hide these details (which is also a pain at times). sometimes you're forced to go well out of your way in order to achieve the class interface you need (with the proper levels of visibility).
2) you want auto-generated accessors
implementing nonspecialized accessors is tedious, and error prone. it's better to save the time and let the compiler generate them for you.
3) to document behavior
sometimes it's better to write #property (copy) NSString * title; instead of over-documenting the expected result.
4) stricter selector matching with dot-syntax
the compiler performs stricter selector matching. prefer to catch the errors/issues at compilation, if possible.
5) to force the subclasses to use them instead of handling the ivars directly
objc ivars are protected by default. you'll often want them to be private (depending on how the class is used and distributed, or just to ensure the subclass uses the base class correctly).
there are a ton of reasons for this. threading and maintenance are the big ones.
if you declare the ivar as private and provide a property for the subclass to use, then the subclass is forced to use the property in their implementation (although there are ways they could cheat) rather than giving them direct access to the ivar.
so... it ultimately depends on your preference, and the implementation details of your class, paired with the interfaces you're using. i don't think there's a hard and fast rule here - lesser evils and convenience are key motivations.