C, the Foundation of Objective-C
- The Structure of a C Program
- Variables
- Operators
- Expressions and Statements
- Program Flow
- Preprocessor
- Command Line Compiling and Debugging
- Summary
- Exercises
This chapter is from the book
This chapter is from the book
This chapter is from the book
Objective-C is an extension of C. Most of this book concentrates on what Objective-C adds to C. But in order to program in Objective-C, you have to know the basics of C. When you do such mundane things as add two numbers together, put a comment in your code, or use an if statement, you do them the identical way in both C and Objective-C. The non-object part of Objective-C isn’t similar to C, or C-like, it is C. Objective-C 2.0 is currently based on the C99 standard for C.
This chapter begins a two-chapter review of C. The review isn’t a complete description of C; it covers only the basic parts of the language. Topics such as bit operators, the details of type conversion, Unicode characters, macros with arguments, and other arcana are not mentioned. It is intended as an aide-mémoire for those whose knowledge of C is rusty, or as a quick reference for those who are adept at picking up a new language from context. The following chapter continues the review of C and treats the topics of declaring variables, variable scope, and where in memory C puts variables. If you are an expert C/C++ programmer, you can probably skip this chapter. (However, a review never hurts. I learned some things in the course of writing the chapter.) If you are coming to Objective-C from a different C-like language, such as Java or C#, you should probably at least skim the material. If your only programming experience is with a scripting language, or if you are a complete beginner, you will probably find it helpful to read a book on C in parallel with this book.
There are many books on C. The original Kernighan and Ritchie book, The C Programming Language, is still one of the best.1 It is the book many people use to learn C. For a language lawyer’s view of C, or to explore some of the darker corners of the language, consult C: A Reference Manual by Harbison and Steele.2
Think for a moment about how you might go about learning a new natural language. The first thing to do is look at how the language is written: Which alphabet does it use? (If it uses an alphabet at all; some languages use pictographs.) Does it read left to right, right to left, or top to bottom? Then you start learning some words. You need at least a small vocabulary to get started. As you build your vocabulary, you can start making the words into phrases, and then start combining your phrases into complete sentences. Finally, you can combine your sentences into complete paragraphs.
This review of C follows roughly the same progression. The first section looks at the structure of a C program, how C code is formatted, and the rules and conventions for naming various entities. The subsequent sections cover variables and operators, which are roughly analogous to nouns and verbs in a natural language, and how they are combined into longer expressions and statements. The last major section covers control statements. Control statements allow a program to do more interesting things than execute statements in a linear sequence. The final section of the review covers the C preprocessor, which allows you to do some programmatic editing of source files before they are sent to the compiler, and the printf function, which is used for character output.
The Structure of a C Program
This chapter begins by looking at some structural aspects of a C program: the main routine, formatting issues, comments, names and naming conventions, and file types.
main Routine
All C programs have a main routine. After the OS loads a C program, the program begins executing with the first line of code in the main routine. The standard form of the main routine is as follows:
int main(int argc, const char *argv[])
{
// The code that does the work goes here
return 0;
}
The key features are:
- The leading int on the first line indicates that main returns an integer value to the OS as a return code.
- The name main is required.
- The rest of the first line refers to command line arguments passed to the program from the OS. main receives argc number of arguments, stored as strings in the array argv. This part isn’t important for the moment; just ignore it.
- All the executable code goes between a pair of curly brackets.
- The return 0; line indicates that a zero is passed back to the OS as a return code. In Unix systems (including Mac OS X and iOS), a return code of zero indicates “no error” and any other value means an error of some sort.
If you are not interested in processing command line arguments or returning an error code to the OS (for example, when doing the exercises in the next several chapters), you can use a simplified form of main:
int main( void )
{
}
The void indicates that this version of main takes no arguments. In the absence of an explicit return statement, a return value of zero is implied.
Formatting
Statements are terminated by a semicolon. A whitespace character (blank, tab, or newline) is required to separate names and keywords. C ignores any additional whitespace: Indenting and extra spaces have no effect on the compiled executable; they may be used freely to make your code more readable. A statement can extend over multiple lines; the following three statements are equivalent:
distance = rate*time;
distance = rate * time;
distance =
rate *
time;
Comments
Comments are notations for the programmer’s edification. The compiler ignores them.
C supports two styles of comments:
- Anything following two forward slashes (//) and before the end of the line is a comment. For example:
// This is a comment.
Anything enclosed between /* and */ is also a comment:
/* This is the other style of comment */
The second type of comment may extend over multiple lines. For example:
/* This is
a longer
comment. */
It can be used to temporarily “comment out” blocks of code during the development process.
This style of comment cannot be nested:
/* /* WRONG - won't compile */ */
However, the following is legal:
/*
// OK - You can nest the two slash style of comment
*/
Variable and Function Names
Variable and function names in C consist of letters, numbers, and the underscore character (_):
- The first character must be an underscore or a letter.
- Names are case sensitive: bandersnatch and Bandersnatch are different names.
- There cannot be any whitespace in the middle of a name.
Here are some legal names:
j taxesForYear2012 bananas_per_bunch bananasPerBunch
These names are not legal:
2012YearTaxes rock&roll bananas per bunch
Naming Conventions
As a kindness to yourself and anyone else who might have to read your code, you should use descriptive names for variables and functions. bpb is easy to type, but it might leave you pondering when you return to it a year later; whereas bananas_per_bunch is self-explanatory.
Many plain C programs use the convention of separating the words in long variable and function names with underscores:
apples_per_basket
Objective-C programmers usually use CamelCase names for variables. CamelCase names use capital letters to mark the beginnings of subsequent words in a name:
applesPerBasket
Names beginning with an underscore are traditionally used for variables and functions that are meant to be private, or for internal use:
_privateVariable _leaveMeAlone
However, this is a convention; C has no enforcement mechanism to keep variables or functions private.
Files
The code for a plain C program is placed in one or more files that have a .c filename extension:
ACProgram.c
Code that uses the Objective-C objects (the material covered starting in Chapter 3, “An Introduction to Object-Oriented Programming”) is placed in one or more files that have a .m filename extension:
AnObjectiveCProgram.m
There are some naming conventions for files that define and implement Objective-C classes (discussed in Chapter 3), but C does not have any formal rules for the part of the name preceding the filename extension. It is silly, but not illegal, to name the file containing the code for an accounting program
MyFlightToRio.m
C programs also use header files. Header files usually contain various definitions that are shared by many .c and .m files. Their contents are merged into other files by using an #include or #import preprocessor directive. (See Preprocessor later in this chapter.) Header files have a .h filename extension as shown here:
AHeaderFile.h