Chapter 2: Understanding Program Structure

A C program, as in most programming languages, consists of a sequence of small, individual pieces of computational work called statements, which can form larger building blocks called functions, which are then compiled into a single program.

In the previous chapter, we learned about the basic development process. While understanding the process is fundamental, programming is principally about solving problems. This chapter will introduce one of the most important aspects of solving problems in any programming language: the ability to break a problem into smaller parts and then focus on solving each smaller problem. You can then use those parts as necessary to combine them into a complete program/solution. This is done by creating and using functions. As we examine these programming elements throughout this chapter, we will expand on the main() function, which we encountered in the previous chapter.

The following topics will be covered...

Technical requirements

Throughout the rest of this book, unless otherwise mentioned, you will continue to use your computer with the following:

• A plaintext editor of your choice
• A console, terminal, or command-line window (depending on your OS)
• A compiler – either the GNU Compiler Collection (GCC) or Clang (clang) for your particular OS

For consistency, it is best if you use the same computer and programming tools for all of the exercises. By doing so, you can focus more closely on the details of C.

The source code for this chapter can be found at https://github.com/PacktPublishing/Learn-C-Programming-Second-Edition/tree/main/Chapter02. Continue to type in the source code yourself and get your versions of the programs to run correctly.

Introducing statements and blocks

Before we begin to explore the details of statements, let's return to the various uses of punctuation that we encountered in our Hello, world! program. Here is the program for reference; comments have been removed so that we can concentrate on the details of the code:

#include<stdio.h>

int main()  {

  printf( "Hello, world!\n" );

  return 0;

}

First, I'd like to draw your attention to the paired punctuation – the punctuation that occurs with a beginning mark and an ending mark. Going through it line by line, we can see the following pairs – < and >, ( and ) (which occur on two lines), { and }, and " and ". We can also see some other punctuation that may or not be familiar to you. These are #, ., ;, \, <space>, and <newline>. These punctuation marks are significant in the C language.

When we look closely at our "Hello, world!\n...

Introducing functions

Functions are callable segments of program code that perform one or more statements of related computational work. Functions group statements into a cohesive set of instructions that perform a specific, complex task. This may comprise a single statement, only a few statements, or many statements. Functions can also call other functions. Functions made up of one or more statements, are the next, higher-up, more complex units of program composition. Statements make functions; functions make programs. main() is a function made of statements and other functions.

The process of writing programs – or rather, solving a given problem – with a computer program is primarily the task of breaking the problem down into smaller pieces – into functions – and focusing on the work to be done in each smaller piece. When we break a problem down into smaller parts, we can easily see the essence of the problem. We can focus...

Understanding function definitions

Functions are an essential part of any C program. Each function that you will create has the following parts:

• Function identifier: This is the name of the function. The name of the function should match what it does closely.
• Function result type or return value type: Functions can return a value to the caller; the caller may ignore the result. If a return value type is specified, the function must return a value of that type to the caller.
• Function block: A block that's directly associated with the function name and parameter list where additional statements are added to perform the work of the function.
• Return statement: The primary mechanism to return a value of the specified type from the called function to its caller.
• Function parameter list: This is an optional list of values that are passed ...

Order of execution

When a program executes, it finds main() and begins executing statements in the main() function block. Whenever a function call statement is encountered, several actions occur:

1. If there are function parameters, the actual values that are found in the function call statement are assigned to the function parameter names.
2. Program execution jumps to that function and begins executing statements in that function block.
3. Execution continues until either a return statement is encountered or the end of the block is encountered (the closing }).
4. Execution jumps back, or returns, to the calling function and resumes from that point.

If, in Step 2, execution encounters another function call statement, the steps are repeated from Step 1.

The following diagram illustrates the call/return order of execution when function calls are encountered. Notice that in every case, the called function returns to the location of...

Understanding function declarations

For the compiler to recognize a function call when it sees it, it must already know about the function. In other words, it must process the function statement's definition before it can process the call to that function. We have seen this behavior in all of our programs up to this point. In each program, we have defined the function and then, later in our program, called it.

This behavior is somewhat limiting since we may want to call a function from anywhere in our program. We don't want to get caught up in its relative position in the program and have to reshuffle the definitions of the functions just to make the compiler happy. The compiler is supposed to work for us, not the other way around.

C provides a way to declare a function so that the compiler knows just enough about the function to be able to process a call to the function before it processes the function definition. These are called function declarations...

Summary

In this chapter, we began with a very simple C program and explored C statements. We expanded and changed our program through the use of functions. We saw how to define functions, call them, and declare function prototypes. Lastly, we saw how we can structure our programs using a top-down or bottom-up approach when implementing our programs.

Thinking about solving a problem in terms of breaking it down into smaller pieces, and then solving each via functions, is an essential skill to be able to solve complex problems in any programming language.

As we explore the remainder of the C syntax, we will demonstrate each feature through functions. We will explore how we can change functions to make our programs either more appropriate to our problem or to make it easier to understand how the problem is being solved.

In the next chapter, we will begin to develop an understanding of data types. Data types determine how to interpret values and what kind of manipulation can be...

Questions

Answer the following questions to test your knowledge of this chapter:

1. Can you name the five types of statements we have already encountered?
2. Can you name the three types of statements we have not encountered yet?
3. Can you name the five parts of a function definition?
4. What is another name for a function declaration?
5. What is the difference between the function declaration and the function definition?
6. Is a return statement always required? If not, why not?