- Compiling and Running Programs
- Explanation of Your First Program
- Displaying the Values of Variables
- Summary
- Exercises
This chapter is from the book
This chapter is from the book
This chapter is from the book
Explanation of Your First Program
Now that you are familiar with the steps involved in compiling and running Objective-C programs, let’s take a closer look at this first program. Here it is again:
// First program example
int main (int argc, const char * argv[])
{
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog (@"Programming is fun!");
[pool drain];
return 0;
}
In Objective-C, lowercase and uppercase letters are distinct. Also, Objective-C doesn’t care where on the line you begin typing—you can begin typing your statement at any position on the line. You can use this to your advantage in developing programs that are easier to read.
The first line of the program introduces the concept of the comment:
// First program example
A comment statement is used in a program to document a program and enhance its readability. Comments tell the reader of the program—whether it’s the programmer or someone else whose responsibility it is to maintain the program—just what the programmer had in mind when writing a particular program or a particular sequence of statements.
You can insert comments into an Objective-C program in two ways. One is by using two consecutive slash characters (//). The compiler ignores any characters that follow these slashes, up to the end of the line.
You can also initiate a comment with the two characters / and *. This marks the beginning of the comment. These types of comments have to be terminated. To end the comment, you use the characters * and /, again without any embedded spaces. All characters included between the opening /* and the closing */ are treated as part of the comment statement and are ignored by the Objective-C compiler. This form of comment is often used when comments span many lines of code, as in the following:
/*
This file implements a class called Fraction, which
represents fractional numbers. Methods allow manipulation of
fractions, such as addition, subtraction, etc.
For more information, consult the document:
/usr/docs/classes/fractions.pdf
*/
Which style of comment you use is entirely up to you. Just note that you can’t nest the /* style comments.
Get into the habit of inserting comment statements in the program as you write it or type it into the computer, for three good reasons. First, documenting the program while the particular program logic is still fresh in your mind is far easier than going back and rethinking the logic after the program has been completed. Second, by inserting comments into the program at such an early stage of the game, you can reap the benefits of the comments during the debug phase, when program logic errors are isolated and debugged. Not only can a comment help you (and others) read through the program, but it also can help point the way to the source of the logic mistake. Finally, I haven’t yet discovered a programmer who actually enjoys documenting a program. In fact, after you’ve finished debugging your program, you will probably not relish the idea of going back to the program to insert comments. Inserting comments while developing the program makes this sometimes tedious task a bit easier to handle.
This next line of Program 2.1 tells the compiler to locate and process a file named Foundation.h:
#import <Foundation/Foundation.h>
This is a system file—that is, not a file that you created. #import says to import or include the information from that file into the program, exactly as if the contents of the file were typed into the program at that point. You imported the file Foundation.h because it has information about other classes and functions that are used later in the program.
In Program 2.1, this line specifies that the name of the program is main:
int main (int argc, const char *argv[])
main is a special name that indicates precisely where the program is to begin execution. The reserved word int that precedes main specifies the type of value main returns, which is an integer (more about that soon). We ignore what appears between the open and closed parentheses for now; these have to do with command-line arguments, a topic we address in Chapter 13, “Underlying C Language Features.”
Now that you have identified main to the system, you are ready to specify precisely what this routine is to perform. This is done by enclosing all the program statements of the routine within a pair of curly braces. In the simplest case, a statement is just an expression that is terminated with a semicolon. The system treats all the program statements included between the braces as part of the main routine. Program 2.1 has four statements.
The first statement in Program 2.1 reads
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
It reserves space in memory for an autorelease pool. We discuss this thoroughly in Chapter 17, “Memory Management.” Xcode puts this line into your program automatically as part of the template, so just leave it there for now.
The next statement specifies that a routine named NSLog is to be invoked, or called. The parameter, or argument, to be passed or handed to the NSLog routine is the following string of characters:
@"Programming is fun!"
Here, the @ sign immediately precedes a string of characters enclosed in a pair of double quotes. Collectively, this is known as a constant NSString object.
The NSLog routine is a function in the Objective-C library that simply displays or logs its argument (or arguments, as you will see shortly). Before doing so, however, it displays the date and time the routine is executed, the program name, and some other numbers we don’t describe here. Throughout the rest of this book, we don’t bother to show this text that NSLog inserts before your output.
You must terminate all program statements in Objective-C with a semicolon (;). This is why a semicolon appears immediately after the closed parenthesis of the NSLog call.
Before you exit your program, you should release the allocated memory pool (and objects that are associated with it) with a line such as the following:
[pool drain];
Again, Xcode automatically inserts this line into your program for you. Again, we defer detailed explanation of what this does until later.
The final program statement in main looks like this:
return 0;
It says to terminate execution of main and to send back, or return, a status value of 0. By convention, 0 means that the program ended normally. Any nonzero value typically means some problem occurred—for example, perhaps the program couldn’t locate a file that it needed.
If you’re using Xcode and you glance back to your Debug Console window (refer to Figure 2.8), you’ll recall that the following displayed after the line of output from NSLog:
){kind=link}
The Debugger has exited with status 0.
You should understand what that message means now.
Now that we have finished discussing your first program, let’s modify it to also display the phrase “And programming in Objective-C is even more fun!” You can do this by simply adding another call to the NSLog routine, as shown in Program 2.2. Remember that every Objective-C program statement must be terminated by a semicolon.
Program 2.2.
#import <Foundation/Foundation.h>
int main (int argc, const char *argv[])
{
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog (@"Programming is fun!");
NSLog (@"Programming in Objective-C is even more fun!");
[pool drain];
return 0;
}
If you type in Program 2.2 and then compile and execute it, you can expect the following output (again, without showing the text that NSLog normally prepends to the output):
Program 2.2. Output
Programming is fun! Programming in Objective-C is even more fun!
As you will see from the next program example, you don’t need to make a separate call to the NSLog routine for each line of output.
First, let’s talk about a special two-character sequence. The backslash (\) and the letter n are known collectively as the newline character. A newline character tells the system to do precisely what its name implies: go to a new line. Any characters to be printed after the newline character then appear on the next line of the display. In fact, the newline character is very similar in concept to the carriage return key on a typewriter (remember those?).
Study the program listed in Program 2.3 and try to predict the results before you examine the output (no cheating, now!).
Program 2.3.
#import <Foundation/Foundation.h>
int main (int argc, const char *argv[])
{
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog (@"Testing...\n..1\n...2\n....3");
[pool drain];
return 0;
}
Program 2.3. Output
Testing... ..1 ...2 ....3