1.1 Overview

C distinguishes between function declarations, which show how a function is to be called, and function definitions, which provide the implementation detail. This chapter introduces the all-important distinction, and later chapters put the distinction to use in a variety of examples. The chapter also compares C functions with assembly-language blocks, which is helpful in clarifying how C source code compiles into machine-executable code.

Every general-purpose programming language has control structures such as tests and loops. Once again, short code examples introduce the basics of C’s principal control structures; later code examples expand and refine this first look at control structures.

1.2 The Function

The add2 example (see Listing 1-1) contrasts a function’s declaration with its definition. The declaration has no body of statements enclosed in braces, but the definition must have such a body. In a contrived example, the body could be empty, but the braces still would be required in the definition and absent from the declaration.

Program structure may require that a function be declared and defined separately. For instance, if a program’s functions are divided among various source files, then a function defined in a given file would have to be declared in another file to be visible there. Examples are forthcoming.

As noted, a function’s body is enclosed in braces, and each statement within the body ends with a semicolon. Indentation makes source code easier to read but is otherwise insignificant—as is the placement of the braces. My habit is to put the opening brace after the argument list and the closing brace on its own line.

In a program, each function must be defined exactly once and with its own name, which rules out the name overloading (popular in languages such as Java) in which different functions share a name but differ in how they are invoked. A function can be declared as often as needed. As promised, an easy way of handling declared functions is forthcoming.

If a C function does not return a value, then void is used in place of a return data type. The term void, which is shorthand for no value, is technically not a data type in C; for instance, there are no variables of type void. By contrast, int is a data type. An int variable holds a signed integer value and so is able to represent negative and nonnegative values alike; the underlying implementation is almost certainly 32 bits in size and almost certainly uses the 2’s complement representation, which is clarified later.

There are various C standards, which relax some rules of what might be called orthodox C. Furthermore, some C compilers are more forgiving than others. In orthodox C , for example, there are no nested function definitions: one function cannot be defined inside another. Also, later standardizations of C extend the comment syntax from the slash-star opening and star-slash closing illustrated in Listing 1-1, and an until-end-of-line comment may be introduced with a double slash. To make compilation as simple as possible, my examples stick with orthodox C, avoiding constructs such as nested functions and double slashes for comments.

1.3 The Function main

In style, C is a procedural or imperative language, not an object-oriented or functional one. The program modules in a C program are functions, which have global scope or visibility by default. There is a way to restrict a function’s scope to the file in which the function is defined, as a later chapter explains. The functions in a C program can be distributed among arbitrarily many different source files, and a given source file can contain as many functions as desired.

This directive is used during the compilation process, with details to follow. The file stdio.h, with h for header, is an interface file that declares input/output functions such as printf , with the f for formatted. The angle brackets signal that stdio.h is located somewhere along the compiler’s search path (on Unix-like systems, in a directory such as /usr/include or /usr/local/include). The implementation of a standard function such as printf resides in a binary library (on Unix-like systems, in a directory such as /usr/lib or /usr/local/lib), which is linked to the program during the full compilation process.

at the command-line prompt and then hits the Return key, a system function in the exec family (e.g., execv) executes. This exec function then calls the main function in the add2 program, and main returns 0 to the exec function to signal normal termination (EXIT_SUCCESS). Were the add2 program to terminate abnormally, the main function might return the negative value -1 (EXIT_FAILURE). The symbolic constants EXIT_SUCCESS and EXIT_FAILURE are clarified later.

1.4 C Functions and Assembly Callable Blocks

The function construct is familiar to any programmer working in a modern language. In object-oriented languages , functions come in special forms such as the constructor and the method. Many languages, including object-oriented ones, now include anonymous or unnamed functions such as the lambdas added in object-oriented languages such as Java and C#, but available in Lisp since the 1950s. C functions are named.

Most languages follow the basic C syntax for functions, with some innovations along the way. The Go language , for example, allows a function to return multiple values explicitly. Functions are straightforward with respect to flow of control: one function calls another, and the called function normally returns to its caller. Information can be sent from the caller to the callee through arguments passed to the callee; information can be sent from the callee back to the caller through a return value. Even in C, which allows only a single return value at the syntax level, multiple values can be returned by returning an array or other aggregate structure. Additional tactics for returning multiple values are available, as shown later.

In the array to which msg points, the last character is called the null terminator because its role is to mark where the string ends. As a nonprinting character, the null terminator is perfect for the job. Of interest now is how the assembly code represents a string literal.

The second point of interest is the call to the printf function . In this version of printf, two arguments are passed to the function: the first argument is a format string, which specifies string (%s) as the formatting type; the second argument is the pointer variable msg, which points to the greeting by pointing to the first character H. The third and final point of interest is the value 0 (EXIT_SUCCESS) that main returns to its caller, some function in the exec family.

The hi program in assembly code (see Listing 1-5) uses AT&T syntax. There are alternatives, including so-called Intel assembly. The AT&T version has advantages , which are explained in the forthcoming discussions. In the example, the ## symbols introduce my comments.

The essentials of this assembly code example begin with two labels . The first, .LC0:, locates the string greeting “Hello, world!”. This label thus serves the same purpose as the pointer variable msg in the C program. The label main: locates the program’s entry point and, in this way, the callable code block that makes up the body of the main: routine.

Although assembly-language programs are made up of callable routines rather than functions in the C sense, it is common and, indeed, convenient to talk about assembly functions. For the most part, the machine-language library routines originate as C functions that have been translated first into assembly language and then into machine code (see the sidebar).

1.5 Passing Command-Line Arguments to main

Later examples put the command-line arguments to use. The point for now is that even main can have arguments passed to it. Both of the control structures used in this program, the if test and the for loop, now need clarification.

1.6 Control Structures

The straight-line program (see Listing 1-8) consists of the single function main, whose body has four statements, labeled in the comments for reference. There are no tests, loops, or function calls that interfere with the straight-line execution: first statement 1, then statement 2, then statement 3, and then statement 4. The last statement exits main and thereby effectively ends the program’s execution. Straight-line execution is fast, but program logic typically requires a more nuanced flow of control.

A conditional expression consists of a test, which yields one of two values: one value if the test is true and another if the test is false. The test evaluates to true (nonzero in C, with a default of 1) because n is 111 and k is 98, making the expression (n > k) true; hence, variable r is assigned the value of the expression immediately to the right of the question mark, k + 1 or 99. Otherwise, variable r would be assigned the value of the expression immediately to the right of colon, in this case 110. The expressions after the question mark and the colon could themselves be conditional expressions, but readability quickly suffers.

The conditional operator is convenient and is used commonly to assign a value to a variable or to return a value from a function. This operator also highlights a general rule in C syntax: tests are enclosed in parentheses, in this example, (n > k). The same syntax applies to if-tests and to loop-tests. Parentheses always can be used to enhance readability, as later examples emphasize, but parentheses are required for test expressions.

Using braces to enclose even a single body statement is admirable but rare.

The last section of the tests program introduces the switch construct , which should be used with caution. The switch expression, in this case the value of variable r, is enclosed as usual in parentheses. The value of r now determines the flow of control. Four case clauses are listed, together with an optional default at the end. The value of r is zero, which means control moves to case 0 and the puts statement is executed. However, there is no break statement after this puts statement—and so control continues through the next case, in this example case 1; hence, the second puts statement executes. If the value of r happened to be 2, only one puts statement would execute because the case 2 body consists of the puts statement followed by a break statement.

The body of a case statement can consist of arbitrarily many statements. The critical point is this: once control enters a case construct, the flow is sequential until either a break is encountered or the switch construct itself is exited. In effect, the case expressions are targets for a high-level goto, and control continues straight line until there is a break or the end of the switch.

The break statement can be used to break out of a switch construct, or out of a loop. The discussion now turns to loops.

C has three looping constructs: while, do while, and for. Any one of the three looping constructs is sufficient to implement program logic, but each type of loop has its natural uses. For instance, a counted loop that needs to iterate a specified number of times could be implemented as while loop, but a for loop readily fits this bill. A conditional loop that iterates until a specified condition fails to hold is implemented naturally as a while or a do while loop.

The whiling program (see Listing 1-10) prompts the user for a nonnegative integer and then prints its value. The program does not otherwise validate the input but rather assumes that only decimal numerals and, perhaps, the minus sign are entered. The focus is on contrasting a while and a do while for the same task.

This loop might be an infinite one except that there is a break statement, which exits the loop: if the user enters a nonnegative integer, the break executes.

The do while loop is better suited for the task at hand: first, the user enters a value, and only then does the loop condition test whether the value is greater than zero; if so, the loop exits. In both loops, the scanf function is used to read user input. The details about scanf and its close relatives can wait until later.

1.7 Normal Flow of Control in Function Calls

A called function usually returns to its caller. If a called function returns a value, the function has a return statement that both returns the value and marks the end of the function’s execution: control returns to the caller at the point immediately beyond the call. A function with void instead of a return type might contain a return statement, but without a value; if not, the function returns after executing the last statement in the block that makes up the function’s body.

Further examples flesh out the details in the return-to-caller pattern. One such example analyzes the assembly code in the pattern. A later example looks at abnormal flow of control through signals, which can interrupt an executing program and thereby disrupt the normal pattern.

1.8 Functions with a Variable Number of Arguments

The sysCall program (see Example 1-2) invokes the library function syscall , which takes a variable number of arguments; the first argument, in this case the symbolic constant SYS_chmod, is required. SYS_chmod is clarified shortly.

The syscall function is an indirect way to make system calls, that is, to invoke functions that execute in kernel space, the address space reserved for those privileged operating system routines that manage shared system resources: processors, memory, and input/output devices. This indirect approach allows for fine-tuning that the direct approach might not provide. This example is contrived in that the function chmod (change mode) could be called directly with the same effect. The mode refers to various permissions (e.g., read and write permissions) on the target, in this case a directory on the local file system.

The varArgs program (see Example 1-3) defines a function avg with one named argument count and then an ellipsis that represents the variable number of other arguments. In this example, the int parameter count is a placeholder for the required argument, which specifies how many other arguments there are. In the first call from main to the function avg , the first 4 in the list become count, and the remaining four values make up the variable arguments.

In the function avg , local variable nums is declared to be of type va_list. The utility va_start is called with args as its first argument and count as its second. The effect is to provide storage for the variable arguments. The later call to va_end signals that this storage no longer is needed. Between the two calls, the va_arg utility is used to extract from the list one int value at a time. The programmer needs to specify, in the second argument to va_arg, the data type of the variable arguments. In this example, the type is the same throughout: int. In a richer example, however, the type could vary from one argument to the next. Finally, function main makes three calls to function avg, including a call that has no arguments other than the required one, which is 0.

1.9 What’s Next?

C has basic or primitive data types such as char (8 bits), int (typically 32 bits), float (typically 32 bits), and double (typically 64 bits) together with mechanisms to create arbitrarily rich, programmer-defined types such as Employee and digital_certificate. Names for the primitive types are in lowercase. Data type names, like identifiers in general, start with a letter or an underscore, and the names can contain any mix of uppercase and lowercase characters together with decimal numerals. Most modern languages have naming conventions similar to those in C. The basic types in C deliberately match the ones on the underlying system, which is one way that C serves as a portable assembly language. The next chapter focuses on data types, built-in and programmer-defined.