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.

NOTE

I recommend that everyone read Chapter 2, “More about C Variables.” In my experience, many who should be familiar with the material it contains are not familiar with that material.

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:

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

NOTE

Mac OS X filenames are not case sensitive. The filesystem will remember the case you used to name a file, but it treats myfile.c, MYFILE.c, and MyFile.c as the same filename. However, filenames on iOS are case sensitive.

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

NOTE

Because C is a proper subset of Objective-C, it’s OK to put a plain C program in a .m file.

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

NOTE

It is possible to mix Objective-C and C++ code in the same program. The result is called Objective-C++. Objective-C++ code must be placed in a file with a .mm filename extension: