Interfacing with C plus plus-programing communication with microcontrolers (K. Bentley, 2006)

1

Getting Started

Inside this Chapter

1 GETTING STARTED 3

contents of the editor into a file. The two editors mentioned above will only store what you type. They will not add extra characters to your file (unlike some editors). What we normally type includes digits, letters, punctuation marks, the space, tab, carriage return and line-feed characters. The line-feed character is used by the editor to position the cursor on a new line. The carriage return character is used by the editor to position the cursor at the start of the next line. A program file must not contain characters apart from those listed above. The file that contains all programming instructions, is known as the source file. The source file is said to contain the source code, which is nothing more than the programming instructions you typed.

1.2.2 Compiling

The second step is to compile the source file. For this purpose, a special program known as a compiler is used. As part of the compiler, a program named the preprocessor is invoked. This takes place before the actual compilation of your source code. The preprocessor attends to your source code statements that start with the '#' sign. (See the program listings ahead for the lines starting with a ‘#’ sign). These statements are referred to as compiler directives. The preprocessor takes action as directed by these statements and will modify your original source file. At the end of preprocessing, all lines starting with the '#' sign will have been processed and eliminated. This process is shown in Figure 1-1. The preprocessor and the compiler are gradually becoming merged - most modern compilers have the preprocessor as a built-in part of the compiler itself.

Figure 1-1 Preprocessor attends to all lines starting with '#' symbol.

The compiler in-turn processes the file produced by the preprocessor and produces a file known as an object file. The object file contains what is known as object code, which the Central Processing Unit (CPU) of your computer understands, also known as machine code. However, the PC cannot execute the object code since it

41 GETTING STARTED

still has a few parts missing. At this stage your program is in a similar state to an unfinished highway with some stretches complete and others not. As a result, the compiled program cannot yet be executed (i.e. run on your computer).

At this incomplete stage, the object code is said to contain undefined references. The undefined references refer to pieces of object code that need to be retrieved from elsewhere to complete the entire program. Just like the highway, the object file does not have a continuous execution path. The compiling process is shown in Figure 1-2.

Figure 1-2 The compiler converts the source code to object code.

The syntax used as part of the program statements is extremely important. As mentioned earlier, syntax refers to the use of punctuation marks within the source file. Most of the time these punctuation marks act as delimiters. A delimiter identifies the end of variables, keywords, numbers, statements etc. The space, the comma, the semicolon, the colon, the brace etc., act as delimiters for different contexts of usage. Compilers have limited in-built intelligence. If you miss a semicolon the compiler will detect it and report an error, but it cannot correct the error for you.

As mentioned earlier, the object code is incomplete with many unresolved areas and it cannot be executed. For example, the object code may contain calls to various routines. The object file includes function calls to be made. The actual instructions to be executed during the call are not yet in place. These instructions may be available elsewhere in the object file, or they may need to come from a library file or another object file. Note that finding the missing bits is not part of the compiler’s duties – the compiler can be viewed in basic terms as a translator that checks grammatical content!

1 GETTING STARTED 5

1.2.3 Linking

The program that bridges all the gaps and completes assembly of the program is known as the linker. It will search all the object files and the libraries to find the missing sets of instructions. Sometimes the linker must be told to search certain libraries and object files. These are either third party libraries you may have purchased or the libraries and object files you developed. The linker automatically searches the libraries and object files that come with the C++ software, one being the so-called Run-Time Library (RTL). The linker will insert the missing sets of instructions into appropriate places to form a file that has a ‘gaps free’ execution path. This process is known as linking. At the end of the linking process, we have a file the PC can execute, known as an executable file.

The program must be loaded into the computer's memory before execution can begin. This action is carried out by a piece of executable code known as a loader. Most linkers append a loader to the start of the executable file. Therefore, when we try to run the program, first the loader will run, loading the program into memory and then actual program execution will begin. Figure 1-3 shows the linking process.

Figure 1-3 Linking forms a gaps-free executable code.

61 GETTING STARTED

1.3 A C++ Program

A computer sees a program as a set of instructions to be executed. The programmer arranges these instructions in a certain order depending on the tasks the computer is expected to perform. To give you a simple example; if you want to write a program to add two numbers, the numbers must be entered first and then the addition must be carried out. Therefore, the instructions to read the numbers must come before the instructions to add the numbers.

Each programming language has its own unique syntax. Syntax is the typography and the use of punctuation marks. Here, we will learn the syntax that applies to the C++ programming language.

As mentioned earlier, the basic building block of a C++ program can be viewed as the function – a procedure that produces an end result. Therefore, every C++ program that contains a set of executable instructions must have a function. One of these functions is special, and is named main. To uniquely identify functions separately from other entities in our text, we use a pair of parentheses () after the function name. Simple programs can be written just with a main() function. When programs become more elaborate and complex, other functions may have to be written in addition to the main() function.

The aim of our first C++ program is to print a text message on the screen of your computer. The lines of this program are given in Listing 1-1.

Listing 1-1 Program to print a text message on the screen.

/* This program prints a text message on your screen. The program consists of just one function named main.*/

#include <iostream.h>

// The main function. void main()

{

cout << “Getting Started “ << endl;

}

If you run this program, you will see the message:

Getting Started

printed on your screen. The following sections explain the composition of this program.

1 GETTING STARTED 7

1.3.1 Comments in Programs

Comments are descriptions included in a program that are used so programmers can document their work. They often describe a program or specific parts of a program and do not form any part of the actual program’s instructions that will run on the computer. If you include comments, you must indicate to the compiler that they are not to be considered as actual code when the compiler prepares the final program prior to execution. There are two different ways to include comments:

(i)To include single line or multi-line comments you can use ‘/*’ at the start of the comment and ‘*/’ at the end of the comment.

(ii)If the comment is a single line comment you may use ‘//’ at the start of the comment.

In Listing 1-1, we have a multi-line comment and a single line comment. The multi-line comment is:

/* This program prints a text message on your screen The program consists of just one function named main().*/

The single line comment is:

// The main function.

The text contained within ‘/*’ and ‘*/’ will be ignored by the compiler. Likewise for the text after ‘//’ on that line.

1.3.2 Header Files

The first line after the multi-line comment of Listing 1-1 is an include statement:

#include <iostream.h>

It instructs the preprocessor to replace that statement with the entire contents of the file iostream.h. In our program this takes place just before the start of the main() function. The files with the file extension ‘.h’ are known as header files or as include files. A header file can already exist within the C++ development software, or it may be a file created by the programmer. If it is a file provided with the C++ development software, then it resides in a special sub-directory known as the Include Directory, as is the case for the iostream.h file. Programs can have more than one include statement, resulting in the inclusion of a number of header files.

The header files are text files that contain C++ programming statements, most of which do not form executable program statements. Not all statements in your program are executable. However, the statements in header files play a major role in the preparation of your program. The majority of the statements in a header file assist the compiler to carry out a thorough check of the program statements you write in your program. Once the header files are written and tested, we do not

81 GETTING STARTED

change them. If the compiler issues error or mismatch messages, then we must change our program – not the header file.

Library routines are ready-made pieces of software we can make use of. The programmers who write the library routines must also prepare the header files belonging to the library routines. By programming in strict conformance with the header files, we are conforming with the library routines we have used that are associated with those same header files.

In the program shown in Listing 1-1 we have used cout, double left arrows ‘<<’, and endl within our program. They do not form part of the C++ language in the context we have used them. Unless we instruct the compiler as to the usage of these elements, the compiler cannot interpret their proper use. The header file iostream.h contains all the necessary programming statements to inform the compiler how the elements should be used. This information must appear before using cout, << and endl. Hence, the include statement appears before the first use of cout, << and endl in our program.

The compiler does not need the entire contents of the file iostream.h to be able to translate the program shown in Listing 1-1 into code that the computer understands. In our example, it would be sufficient to show the part of iostream.h that describes cout, endl, and the behaviour of the operator <<. However, it is very difficult to determine exactly which parts of a header file are necessary for a particular program. Therefore, compilers run through the entire header file. The size of the header files will not have any affect on the size of the executable files, although the time to prepare the program will increase slightly. If necessary, we may need to include more than one header file. In addition, there may be other header files used in each of the ones we include.

In conclusion, the appropriate header file must be included first to provide various definitions of constants and data types, and also to declare various functions before using those constants, data types and functions in a program.

1.3.3 Program Syntax

Syntax refers to the use of punctuation marks in the program. In our program, we have used the # symbol, angle brackets (< >), the pair of parentheses, braces ({}), semi-colon and <<. These punctuation marks must be correctly inserted at the appropriate places before the compiler can recognise your program as being errorfree. The program in Listing 1-1 shows only basic syntax. As programs become more complex, their syntax also becomes more involved.

All lines starting with a hash symbol (#) are instructions to a special part of program development software named the preprocessor, discussed previously.

Our program has just one function – the main() function. The start of the body of the main() function is signified by the open brace ({). The end of the main() function is signified by the close brace (}). Between the two braces are the statements to be executed by the program. Program execution always starts at the

1 GETTING STARTED 9

line that contains main(). It ends at the closing brace of the main() function’s body.

The syntax of the main() function can be expressed in a compact form as shown:

void main(){statement1; statement2; statement3;}

The function has the name main. The pair of parentheses that follow the name main may or may not be empty - in our simple program they are empty. As can be seen, semi-colons are used to separate the statements of the program. Although it may appear redundant, the semi-colon after the last statement is essential.

1.3.4 Keywords

Keywords are words reserved by the language. They must not be used for purposes other than those specified for them by the C++ language. For example, a keyword cannot be used as an identifier. Identifiers are variable names we create to identify various entities such as functions, user created data types and data. So far, the only keyword we have seen is void. A list of keywords is given in Appendix B.

1.3.5 The Return Value Type

The word void right at the start of our main function describes the return value type of the main() function. Every function, let it be the main() function or some other function, must specify a return value type. The return value can be viewed as the end-product or the output produced by the function. If a function is programmed to return a value, the programmer must specify the data type of the value to be returned (to be issued out). It is also possible to program a function to not return a value. Such functions generally carry out some task but do not produce a value to be issued out. For these functions the return value type is void. This is the case in our program. Note that when no values are returned by a function the keyword void must be used to specify the return value type.

NOTE

If a return value type is not specified for the main() function, the return value

type will default to that of an integer. This means the function must produce an integer output.

1.3.6 The Body of main()

The body of the main() function contains just one statement. This line is enclosed within the open brace ({) and the close brace (}). If there is to be more than one statement forming the body of the main() function, they all need to be included within the two braces. The solitary statement in our program reads as:

10 1 GETTING STARTED

cout << “Getting Started “ << endl;

The use of cout will instruct the computer to stream whatever follows to the standard output device, in this case your screen. Streaming has a definition in the C++ language. For now, it’s sufficient to understand streaming as directing one entity (such as a group of characters, an integer, etc.) after another to a certain destination. First, Getting Started will appear on the screen. Next, endl will be streamed to the screen. The effect of this is to position the cursor at the start of a new line on the screen. Execution of the program is now complete.

You can experiment by replacing the previous statement by:

cout << “Getting Started”;

This will only stream Getting Started to the screen. It will not stream endl to the screen. You will see the cursor blinking at the end of the words ‘Getting Started’.

1.4 Use of Functions

As mentioned earlier, functions form an integral, important part of C++ programming. In this section we will learn how to use a function. As explained earlier, a function can be thought of as a procedure that produces some sort of an end result based on the inputs it receives. Some of the inputs the function will receive are known as parameters or formal arguments. The formal arguments are used at the time of programming a function to indicate the type of arguments it can receive. At the time of executing the function in your computer, the formal arguments must be replaced by actual arguments. For example, at the time of programming, we may use a formal argument named a. At the time of executing the function, the formal argument a must be replaced by an actual argument such as the number 3. The same function can be called (executed) again replacing the formal argument with a different actual argument, producing a different return value. It is worth mentioning here that, although the formal way of receiving the output of a function is via the return value, there are other ways of receiving the outputs from functions.

The function outputs a return value.

Only ONE value can be returned.

Function

Parameters are the inputs to the function

Figure 1-4 General schematic of a function.