C PROGRAMMING
Section 1.
Topics: Functions Statements Input Output Variables

Introduction

The C programming language has been the most popular high level language used for engineering applications for the last 20 years. It shares many common structures with other procedural languages, such as Pascal, and can be used for general purpose programming of a PC. However, it is also particularly good for development of embedded application programs such as those found in phones, video recorders and so forth. The term procedural language refers to the fact that the language uses procedures to do particular tasks such as printing on the screen. In C these procedures are known as functions and are described below.

What is so good about a language like C? The basic reason such languages were developed was to make it easier for humans to program computers. The alternative is the language of the computer, i.e., binary codes. Clearly such ‘low-level’ languages are not very appealing for humans, although sometimes necessary for detailed engineering work. (In fact C is often ‘mixed’ with such languages for engineering applications.)

C uses words and symbols that are part of, or similar to, normal language. This makes it easier for programmers to develop code. The C code is converted to the machine code by a special program called a compiler. See note 1. But perhaps the most useful thing about such a language is that it provides the developer with a library of ‘mini-programs’, the functions/procedures someone else has written, thereby allowing the programmer to concentrate on developing his own particular application programs.

Note 1 Typically the code entered by the programmer, known as the source code, is saved in a file with the extension .C . For instance, a program to monitor temperature might be saved in file called tempcont.c . When the compiler produces the machine code it is saved in a file with the same name but the extension is exe (executable) Thus the file tempcont.exe contains the code that the computer requires to execute the program that was written in the file tempcont.c.
The ’mini-programs’ are called functions because they do some function! For instance sound(1000); is the function to make a PC generate a sound (a single tone) at 1000 Hertz. In this example the number in the brackets sets the frequency of the sound. The technical way of describing this is that 1000 is a parameter of the function. This value must be a whole number (integer). The above example is a ‘line of code’ in a C program and referred to as a statement.

A programmer creates his own functions based mainly on the library functions supplied and a few other structures for making decisions and so forth. The following is an example of a user defined (written by the programmer) function called my_sounds

void my_sounds(void) { sound(500); /* make a sound at 500 Hz.*/ delay(2000); /* pause for 2000 milliseconds = 2 seconds */ sound(1000); delay(2000); sound(1500); delay(2000); sound(2000); delay(2000); nosound(); /* turn off sound */ }

The functions used in this example are explained with comments. These are the explanatory pieces of text between /* and */. It is very important to explain (document) the program in this way. It will be easier to understand when it is re-read. The little bit of effort required to add comments can save a lot of time in the long run and is considered as much a part of programming as the C code.

Before the above program can be compiled into executable machine code and run, some necessary additional code must be added. The details about this are not too important at present. A complete program is shown below and explained using comments.

Note 2 Sometimes I will use comments to explain new concepts. This will not be the case in your programs. Your comments should explain what the code is doing at a particular point in the program, particularly if it is a bit complicated. Clearly some things are fairly obvious and may not need a detailed explanation, e.g., what the sound function does. However, most of the user-defined functions need clear concise comments to explain their task and how it is implemented. The comments at the start of the following program should always be present

/**********************************************************************/
/*Title: C program to make sounds (sound1.c) */
/**********************************************************************/
/*Developer: A.C. Programmer 20-10-2000 */
/**********************************************************************/
/*Description: This program uses the sound() function and delay() functions to */
/* demonstrate a simple C program */
/**********************************************************************/
#include /* a special header file that is needed when using the */ /* sound function and so forth */ void my_sounds(void); /* this ‘warns’ the compiler that a ‘new’ user defined */ /* function will appear later- the technical term for this */ /* statement is function prototype and is basically a copy */ /* the first line of the user-defined function */

main() /*All C programs have a main function body */
{ /* the user defined functions are ‘called’ from the main */ my_sounds(); /* function as shown on this line. The ‘calling’ statement */ /* is simply the function name followed by a semi-colon */
} /*The curly braces are used to‘group together’ statements*/ /* inside a function body */
/*-------------------------------------------------------------------------------------------------------*/
/* The my_sound function ………../* void my_sounds(void) { sound(500); /* make a sound at 500 Hz.*/ delay(2000); /* pause for 2000 milliseconds = 2 seconds */ sound(1000); delay(2000); sound(1500); delay(2000); sound(2000); delay(2000); nosound(); /* turn off sound */ }
It would be possible to write all the statements in the my_sounds() function in the main function. However, we shall only use the main function to ‘call’ other functions or for some special sections of code. Why not use the main function?. The principle reason not to use main is to ensure that the program is ‘broken up’ into smaller functions. This is called modular programming and makes it easier to design and understand programs. This is a subject we shall return to at a later stage.

Interactive programs

The previous example program does not allow the user to interact with the computer. For instance it would be interesting to permit the user to select the frequency of the sound and the duration of the delay. To do this 3 extra tasks arise:

1. Output a request to the screen seeking the user to enter values 2. Input values from the keyboard 3. Store these values in the system memory for use later (by the functions sound and so forth)

Output

To output something to the screen the most common function is printf(). The easiest way to start using printf is with a ‘string of characters’ such as

Please enter your frequency selection (

To do this simply enclose the above text in quote marks “like this”, to indicate a string of text to the compiler, and write this between the brackets as shown below

printf(“Please enter your frequency selection ”);

Note how many functions have something between the brackets, the parameters which the function uses. Also, the ever present semi-colon which terminates the statement. The printf function always has something between quote marks “……” and this is called the format string. Further details about printf later. However, there is one extra item that must be learned now. How do you print on a new line and not just follow the previous piece of text on the same line? An escape sequence, which is written inside the format string as \n, .is used. For instance,

printf(“\n\n Now enter the duration of the delay (”);

In this case the two \n sequences cause 2 blank lines to be ‘printed’ before the text starts. Note that the \n appears inside the quote marks. Omitting the quotation marks or the semi-colon at the end of a statement, are the two most likely sources of errors for programming students.

To use printf() it is necessary to include details from a special ‘header file’ called stdio.h. The stdio is an abbreviation of standard input/output. This is written at the start (as in the example which used the dos.h file also) as follows: #include
More details about this later.
Storage (variables)

Before discussing input, we shall consider the storage of data. If a number, or any other form of data, is read in from the keyboard, then there must be some place to store this data. (Physically this is the RAM memory in the system). In order to save data in memory the program must ‘reserve’ some space in the memory and give it a name. This is described as declaring a variable.

You are already familiar with the notion of variables from mathematics, for instance, Y=3X+4
The value of Y depends on the value of X, which may be whatever we choose, i.e., it is variable. In a computer a variable is much the same. It is a memory location(s) that can hold (store) data and its contents may be changed (variable). However, variables can store more than just numbers. For instance they can be used to store text. When declaring a variable it is necessary to indicate what type of “data” is to be stored in it and give it an identifier (name). Declarations of variable appear in the start of functions. For the sound() and delay() functions the parameters are integer values (whole numbers). Thus, a possible declaration for the two variable required might be

/*declarations of variables */

int frequency,duration; /*The words ‘freqency’and ‘duration’*/ /* are the names (identifiers) of the variables*/

In the above example the computer is instructed to reserve memory locations and identify them with the names (identifiers) frequency and duration. Also, the type of data to be stored is specified with the abbreviation int, which is short for integer. (The computer reserves a certain amount of memory depending on the particular data type). A more detailed description of variables will be given at a later stage, but note that the most common type specifier for numbers is the word float. (As in the case of floating point, or decimal point, real numbers – not just whole numbers).
If a variable can store data then there must be a way of ‘loading’ that variable. One way is to use the assignment operator (the equal symbol = ) to assign a value in the way a mathematical expression is constructed

frequency=1000; sound(frequency);

In the two lines of code above the variable frequency is assigned the value 1000 and this is then the frequency of the tone generated by the sound function. But we want the person running the program to select the frequency. Thus we must consider how to input data from the keyboard.

input

For interactive input the most common function is scanf(), the input equivalent of printf(). Similarly to printf() it uses a string, the format string, to input the data from the keyboard. The term format relates to how data is treated for either output to the screen or input from the keyboard. Format specifiers are described in detail later. However, a simple way to understand them is to consider the difference between an ‘int’ such as 2 and a ‘float’ such as 2.0. If someone enters a ‘2’ character at the keyboard, they may want it to be treated as either one or other of the above (or even as something else!). The format specifier is used to specify which format is to be used. For instance, %f means treat it as a float and %d means treat it as an integer (decimal- hence the d).

Thus, for the my_sound function a possible input statement would be

scanf(“%d”,&frequency);

The “%d” is the format string and &frequency indicates where the input (the integer value) is to be stored. There is a particular significance in the & symbol but for the moment simply treat it as meaning ‘at’. (Store input at variable location frequency).
A single statement can read more than 1 input. A space or return is required between each input. The general format for the scanf() function is

scanf (“format string”,&var1,&var2,…)

notice the commas separating the various items in the brackets.

example scanf(“%d %d”, &data_1, &data_2);

This call tells the program that it expects you to type in two decimal (integer) values separated by a space; the first will be assigned to variable data_1 and the second to the variable data_2.

Exercise 1

Modify the the my_sounds() function to do the following

1. Declare int variables for frequency and duration 2. Request the user to select a frequency for the first tone and the duration of the delay. 3. let each subsequent tone be 100Hz higher value than the first tone with the same duration as the first tone, e.g., sound(frequency+100);

Note the use of the addition operator described in the next section..

Operators

The assignment operator was introduced earlier in relation to storing data in variables. As you might expect there are plenty of operators for manipulating variables. To begin with we shall note the common arithmetic operators and introduce others, such as Boolean, as we require them. A full table of operators will be provided later.

= assignment + addition - subtraction * multiplication / division % remainder (applies to integer division)

The usual arithmetic rules for precedence and the use of brackets apply. If integers are divided then the result is also an integer or zero.

Examples

res_total = res_1+res_2+res_3;

the 3 ‘res’ variables store resistance values entered by a person. The series equivalent resistance of the 3 is calculated and assigned to the res_total variable.

Note: a variable name cannot have a space in it. Thus in the above example to give the impression of a space, and make the name easier to read, an underscore symbol is used.

average_age = (age_1+age_2+age_3)/3;

in the above example the 3 ‘age’ variables contain the numbers associated with the ages of 3 people. The average is calculated and assigned to the variable average_age. Because division has a higher precedence than addition, the brackets are used.

Exercise 2

Write a function to request the user to input 2 values corresponding to resistance values and which then does the following

1. calculates the series equivalent resistance 2. calculates the parallel equivalent resistance 3. outputs both results to the screen.

Checkout the detailed description of printf() to see how to print the results..

NOTE 2: Printf function in detail

You’ve already used the most common output function in C, printf(). Its format is both simple and flexible: printf(,,,…);

The Format String

The format string begins and ends with double quotes (“like this”)and printf’s function is to write that string to the screen. First, though, printf substitutes any additional items listed into the string, according to the format commands found in the string itself. For example, your last exercise program may have had the following printf statement:

printf(“The series resistance is %f \n”,series_res);

The %f in the format string is a format specification. All format specifications start with a percent sign (%) and are (usually) followed by a single letter, indicating the type of data and how the data is to be formatted. (Remember in the computer the data is in a binary format and that format is not much good for humans).
You should have exactly one item listed for each format specification. The items themselves can be variables, constants, expressions, function calls. In other words anything that results in a value appropriate to the corresponding format specification.

The %f used in this specification means that a float is expected. The most common format specifications are listed below

- %u (unsigned integer) - %f (floating point) - %e (floating point in exponential format) - %c (single character) - %s (string) - %x or %X (integer in hexadecimal format)

e.g. printf(“The average age is %d”,average_age);

You may have noticed that when printing a value stored in a ‘float’ with %f, a number of decimal places are printed, 6 in all. If you wish to set the total number of characters printed, the field width, and the number of decimal place digits, then you may do this as follows by inserting details between the % and f of the format specifier.

%.f

For instance for a width of 6 and 2 decimal place the earlier example would be

printf(“The series resistance is %6.2f \n”,series_res);

If there are not enough characters (including the decimal place) to fill the width then the value will then be printed out right-justified (with leading blanks), so that the total field width is 6.

If you need to print a percent sign, just insert %%.

As described earlier the \n in the string is an escape sequence not a format specification. It represents a special character inserted into the string. In this case, the \n inserts a newline character, so that after the string is written out, the cursor moves to the start of a new line.

Some of the common escape sequences are listed

\f formfeed or clear screen \t tab \b backspace \n newline -

NOTE 3: Other common screen and keyboard functions

clrscr() puts() getch()

The clrscr() function is used to clear the screen. It requires the conio.h file to be included at the head of the program. The term conio refers to the phrase console input/output Most common functions are associated with the header files stdio.h, conio.h, dos.h, or math.h. Others will be mentioned as required.

The function puts(), as in put string, writes a string to the screen followed by a newline character automatically, without the requirement for the special escape sequence \n
.
For example, you could write

puts (“This is a simple string”);

Similarly the function putchar() writes a single character to the screen, although not commonly used.
For numeric output, or special formatting, printf is required. If only text is to be output then puts is a smaller and faster function and should be used in those cases.

Strings and characters are a particular data type which are described later. There is a variable type ‘char’ which is used for storing text This could be used with scanf(), and the character format specifier %c, to read in a character from the keyboard in the same way numbers may be read in. However, for text there is a simpler method using the getch() function. For example, .char reply; /* character variable */

reply = getch(); /* input from keyboard */

The getch() function causes the program to ‘wait’ for the user to press a character. This is then ‘returned’ and assigned to variable reply. A similar process is involved using gets() when a string of characters is to be entered. (Strings are not dealt with at this stage in detail).

A very useful function for getch() is to simply halt program execution to wait for the user to press a key. In effect it is a ‘pause’ waiting for the user. It will appear in a lot of future programs.

NOTE: 3 Further details about variables and data types

There are 4 basic types of data

integers, floating-point numbers, text, and pointers.

These can be defined as follows

Integers The ‘whole’ number used for counting and so forth (3, 55, -21, and 1052, for example).

Floating-point numbers –numbers with possible fractional portions after the decimal point (27.8976) and exponents (2.579*10^24). Also known as real numbers.

Text -characters (a,b,c…?,!,a and strings (“This is a string.”).

Pointers No details yet!!

Float Types

Most mathematical operations involve real/float numbers and unless required by a function, or for counting, then these should be used for storing numerical data. They occupy more memory space than an integer but this is not significant in modern computers. Typically 6 bytes for a float.

There’s also a large version of type float, known as double. As you might have guessed, variables of type double are twice as large as variables of type float. This means that they have more significant digits and a larger range of exponents. As an exercise determine the largest values that may be stored in these types for your system?

Integer Types

Although int type is sufficient for most purposes, if a very big integer is used then a long can be specified. An int occupies 2 bytes but a long occupies 4 bytes. Normally, we assume that the range of values spans positive and negative numbers. In the variable, the most significant bit represents the + or -. This is referred to as a signed number. It is possible to declare a variable to be ‘unsigned’, thus only positive values may be stored. As an exercise determine the largest numbers that may be stored in the different types of integer variables.

Examples

float var1; .double var2; int var3 long var4; unsigned int var5;

Characters and Strings

A character, such as those input from the keyboard, is a particular data type represented by a character code. This code is known as an ASCII (American Standard Code for Information Interchange) code. Like integer or float data values they may be stored in a variable. The variable is of type char

Example char var_a;

var_a = ‘c’ /* the code for the letter c is assigned to var_a */

Note that in the above example a single character code is ‘generated’ by enclosing the character between single quote marks ‘c’ . A character string, usually several characters, characters is generated between double quote marks. In fact a string consist of a special character called the null character \0 which is always at the end of a string and can be checked for. To store a string a special type character variable is required known as a character array. Consider the following example:

char name [30]; /*declaration of string variable*/

printf(“Enter you name ( “) scanf(“%s”,&name); /* characters stored in name*/
The [30] after name tells the compiler to set aside space for up to 29 characters, that is, an array of 29 char variables. (The 30th space will be filled by a null character. Because of this dependency on a null character, strings in C are known as being null terminated and can be any length, as long as there is enough memory to hold it.

Identifiers

There are restrictions on the identifiers (names) that can be used for variables, functions and other data types. In summary they are

- All identifiers must start with a letter (a…z or A…Z) or an underscore ( _ ).

- The rest of an identifier can consist of letters, underscores, and / or digits (0…9). No other characters are allowed.

- Identifiers are case-sensitive. This means that lowercase letters (a…z) are not the same as uppercase letters (A…Z). For example, the identifiers indx, Indx, and INDX are different and distinct from one another.

- The first 32 characters of an identifier are significant.