I changed this approach and now it works by having a -(void) convertToCelsius; method and then a separate method that returns the value of the calculation. Here is the whole thing:

@interface TemperatureConvert : NSObject
{
  int fahrenheit;
  int celsius;
}
-(void) convertToCelsius;
-(void) setFahrenheit: (int) f;
-(float) celsius;
-(void) print;
 
@end
 
//--------@implementation section------
 
@implementation TemperatureConvert
-(void) print
{
  NSLog (@"%i degrees fahrenheit converted to celsius is %i degrees celsius", fahrenheit, celsius);
}
 
-(void) setFahrenheit: (int) f
{
  fahrenheit = f;
}
 
-(int) fahrenheit
{
  return fahrenheit;
}
 
-(void) convertToCelsius
{
  celsius =(fahrenheit - 32) /1.8;
}
 
-(float) celsius
{
  return celsius;
}
 
@end
 
//--------@programsection--------
 
int main (int argc, const char * argv[]) {
  NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
  //create an instance of a TempConvert
  TemperatureConvert *myTemperatureConvert = [[TemperatureConvert alloc] init];
 
  //set Fahrenheit to 27 degrees
  [myTemperatureConvert setFahrenheit: 101];
 
  //calculate conversion to celsius 
  [myTemperatureConvert convertToCelsius];
 
  //display result of conversion
  NSLog(@"%i degrees fahrenheit converted to celsius is %i degrees celsius",[myTemperatureConvert fahrenheit],[myTemperatureConvert celsius]);
 
  [myTemperatureConvert print];
  [myTemperatureConvert release];
 
    [pool drain];
    return 0;
}

I assume you are closing the interface with an “@end” statement? I don’t get an error when compiling the above, you may have an error in the implementation file…

John

Perhaps someone is willing to take a look and tell me what I am doing wrong? Here is the @ interface section:

@interface TemperatureConvert : NSObject
{
int fahrenheit;
int celsius;
int result;

}
-(int) retrieveResult: (int) r;
-(void) setFahrenheit: (int) f;
-(void) setCelsius: (int) c;
-(void) print;

The voids all work fine… just the getter -(int) retrieveResult: (int) r; produces an error in the program section saying that r is not declared.

Any thoughts?

Greg

With this article I have realized that Programming in Objective-C is very much similar to Java except syntax if considering import of files, getter and setter methods and their return types.

I am trying to create a directory where I want to save the Mobile no and Name of the person and want to same it in the iPhone memry. For this I am using XCode IDE.

Can you please guide me, how can I save data in iPhone memory.

Waiting for your new article on saving data in iPhonr memory.

With regards,

Ankit Thakur

I always use properties (getters and setters) in C# so this definitely helps me understand how to set them up in Obj-C. Same goes for the foreach loop in C# when looping through enumerated objects and seeing how it’s done in Obj-C.

I’m glad to see that Obj-C 2.0 has introduced simpler ways to set properties and iteration loops or I’d have given up. Well, probably not since I love the machine!

Keep ‘em coming!

Using ObjC2 properties forgoes the need to write getter-setter methods entirely:

@interface SomeClass : NSObject
{
NSString *_str;
NSDate *_date;
int _x
}
@property(retain, readwrite) NSString *str;
@property(retain, readwrite) NSDate *date;
@property(assign, readwrite) int x;
:

@implementation SomeClass
@synthesize str = _str;
@synthesize date = _date;
@synthesize x = _x;

In this case the @property declaration, combined with the @synthesize, will automatically generate getter/setter methods for each instance variable — a real time-saver when your class declares a 20 variables (or even if you only declare 1). Since most getter/setter implementations follow the same code template, this can be a nice time saver and leaves the code less cluttered and easier to maintain.

Properties declared with (retain, …) will automatically call [NSObject retain] when a new value is assigned to the instance variable via the synthesized setter, as well as [NSObject release] for the previously assigned object. The “assign” modifier tells the compiler to generate a simple assignment, useful for non-Cocoa variable types, or NSObject references which do not need to be retained. Variables can alternately be declared “readonly”, which generates compiler errors if the code attempts to make an assignment. These are the most common modifiers — the Objective-C 2.0 guide defines others for special cases.

Concurrent with the new property declarations is the change to “.” notation for accessing getter/setting methods.

SomeClass *anInst = [[[SomeClass alloc] init] autorelease];
anInst.str = @”Hello, world!”; // retained
anInst.date = [NSDate date]; // retained
anInst.x = 5; // assigned

The underscore (“_”) notation in the instance variable declarations are optional, but a useful way to distinguish direct variable references from getter/setter references in your code.

@implementation SomeClass
:
- (void) setDefaultX
{
_x = 5; // direct assignment
}

Once you get used to the property syntax, the older form of Objective-C feels clunky.

Fast enumeration is a newer way to iterate through NSArray collections. The traditional way of writing iteration loops is familiar to most Cocoa programmers:

NSArray *aList = [myClass getListOfObjects];
NSEnumerator *anEnum = [aList objectEnumerator];
NSString *aStr = nil;
while (nil != (aStr = [anEnum nextObject])) {…}

With fast enumeration, the same code appears as follows:

NSArray *aList = [myClass getListOfObjects];
for (NSString *aStr in aList) {…}

Not only is it less code, which is always a good thing, but the fast enumeration form allows the compiler to make optimizations in the loop interation that can be several times faster than the older NSEnumerator-based loops.

I find these new features of Objective-C 2.0 to be very handy in writing more compact, readable code, which lets me concentrate more on the logic of my own application, rather than the syntactic overhead of writing classes.

Enjoy!