C Tutorial

Programming in C
A Tutorial
Gary D. Snyder
PEARSON
Boston Columbus Indianapolis New York San Francisco Upper Saddle River
Amsterdam Cape Town Dubai London Madrid Milan Munich Paris Montreal Toronto
Delhi Mexico City Sao Paulo Sydney Hong Kong Seoul Singapore Taipei Tokyo
Contents
Contents
Preface ..................................................................................................................... v
1. Hello, World .................................................................................................... 1
2. Elementary Data Types .................................................................................. 5
3. Input and Output ............................................................................................ 7
4. Arithmetic Operators ................................................................................... 13
5. Logic Operators ............................................................................................ 21
6. Relational Operators .................................................................................... 33
7. Decisions and Conditional Execution.......................................................... 37
8. Loop Statements............................................................................................ 45
9. Derived and Defined Data Types................................................................. 49
10. Strings ............................................................................................................ 61
11. Pointers .......................................................................................................... 69
12. Functions in C ............................................................................................... 75
13. In Conclusion................................................................................................. 87
iii
Preface
Preface
About This Tutorial
Background
The rapid advances in computers and computer technology have a great impact on electronics studies. Computers
and software are standard electronics tools just as the calculators that preceded them were forty years ago. One type
of software consists of application programs, such as SPICE and MultiSIM that allow users to design, simulate, and
evaluate circuit designs before committing them to hardware. Another type of software includes programming
software for languages such as VHDL and C that allow users to customize and configure electronics systems as
specific applications require.
The earliest high-level programming languages, which included Fortran, Algol, COBOL, and BASIC, were closer to
natural language than assembly language and isolated programs from the operating details of the underlying
hardware. This allowed programmers to write code that would run on more than one type of computer but limited
their access to and control of the system hardware. For example, a Fortran program written for an Apple II could be
compiled to run on a TI-99/4 as well, but could not access the individual bits of a decoder.
The C programming language, or simply C, was developed in the early 1970s by Dennis Ritchie to develop the
UNIX operating system on a DEC PDP-11 mainframe. Because an operating system works very intimately with the
system hardware, the C language contains many features that allow the programmer to interact with the system
hardware. Some have called C a “portable assembly language” because it allows programmers to write high-level
programs that can function very much like low-level assembly programs. This makes C a very powerful
programming language, but can create serious problems if programmers are careless.
Purpose
The intent of Programming in C is to introduce the basic concepts of the C programming language. It does so by
discussing features of the C language and providing representative examples of how these features are used in C
functions and programs.
What Programming in C Is
Programming in C is a tutorial. It presents and discusses introductory topics in C programming and the C
programming language. You should (but need not) use it in conjunction with an ANSI C or C-compatible
programming package so that you can further explore and reinforce the topics presented in this tutorial. There are a
number of freeware and academic applications that support the ANSI C standard and can be used with this tutorial.
What Programming in C Is Not

Programming in C is not a software programming course. It does not attempt to cover programming concepts,
programming techniques, data structures, software design, or other programming topics beyond those necessary to
present C programming concepts.
Tutorial Organization
This tutorial consists of 12 chapters, each of which presents a specific C programming topic, and a conclusion. Each
chapter contains sample C program code that the reader can compile to verify and further explore the presented
topic.
How to Use This Tutorial

Programming in C (as in any compiled programming language) consists of three basic steps.
1) Writing the program code.
2) Compiling and linking (building) the program code.
3) Verifying the program code.
v
Programming in C: A Tutorial
The chapters in this tutorial provide examples of C programming code that have been tested to verify that they will
compile and execute properly. However, you should use your programming software to enter, compile, and execute
the examples on you own system. This will allow you to familiarize yourself with your programming software and
personally verify that the code works as intended, reinforcing the presented concepts. Some chapters also contain
some suggested programming exercises for you to explore so that you can gain a better understanding of the C
programming language and C programming.
vi
Section 1 - Hello, World
1. Hello, World
1.1 Overview
The HELLO.C program discussed in this chapter is traditionally the first C program that students write and study.
Although the program does very little it provides a good introduction to the basic structure and features of every C
program that you will write. Because this is only an introduction to C programs some of these features are covered
only briefly and will be discussed more fully in later chapters.
1.2 The HELLO.C Program

The source code, or listing, for the HELLO.C program is shown below. Line numbers are shown for reference only
and are not part of the C program.
1 // HELLO.C
2
3 /* Your first C program */
4
5 #include <stdio.h>
6
7 void main ()
8 {
9 printf ("Hello, world\n");
10 }
When HELLO.C is compiled and run, the program outputs to your monitor the message

Hello, world

The following sections will examine each part of the program and discuss the purpose of each.
1.2.1 Program Comments

Comments are an important part of programming. Comments serve to document the program by explaining how the
program works (or is supposed to work) and providing historical information about the program, such as the
programmers and dates and details of any program changes. Another use for comments is to temporarily remove
sections of code from the program for debugging without actually removing it from the source file. Because the
compiler ignores comments when generating the final executable code, the programmer can essentially remove, or
“comment out”, any part of the program by marking those lines of code as comments.
Line 1 in the HELLO.C listing shows the first way to include a comment in a C program. Any line that begins with
two forward slashes (//) in a C program is a comment. This method applies only to the line that begins with the two
forward slashes.
Line 3 in the HELLO.C listing shows the second way to include a comment in a C program. While the “//”
sequence can be placed at the start of each comment line, this method can be inconvenient (and time consuming) for
comments that require multiple lines. The second method identifies a comment by using a “/*” to indicate the start
of a comment and allows programmers to easily comment blocks (or multiple lines) of code in a program. In this
method a “/*” sequence identifies the start of a comment and a “*/” sequence to identify the end of a comment.
These two sequences and anything between them is considered a comment and ignored by the compiler. Although
Line 3 of HELLO.C places the start and end sequences on the same line they can be placed on separate lines to
create comments that are several lines long. The example below shows how a multiline comment can be used to
create a framed header for a program or C function.
1
/******************************************************************************
* A common use for comments is to add “headers” like this to the start of a *
* program or function to document when the code was written, who wrote it, *
* and how the code works. *
******************************************************************************/
A word of caution is in order regarding the second method for placing comments in a C program. These types of
comments cannot be nested. In other words, you cannot have a block comment inside another block comment. This
is because the “/*” for the inner comment is considered part of the first comment rather than another start of
comment sequence, and the “*/” of the inner comment will end the first comment. The compiler will attempt to
process any lines between the first and second “*/” sequences and probably generate an error. The nested comment
below illustrates this.
/*
This is the start of the outer comment.
The compiler will ignore these lines.
/*
These lines are the intended inner comment, but are considered part of the
outer comment because the end of comment sequence for the outer comment has not
yet occurred. Consequently the start of comment sequence for the inner comment
will be ignored.
*/
This is supposed to be part of the outer comment, but the end of comment
sequence on the previous line has ended the outer comment. The compiler will
try to process these lines and the end of comment sequence on the next line.
*/
1.2.2 Blank Lines

Lines 2, 4 and 6 are blank lines. The C compiler ignores blank lines, which programmers can use freely to make
program listings easier to read. Blank lines, as well as spaces and tabs, are examples of what is called “white space”.
White space is used to separate elements of the program so that the compiler can correctly interpret the code and
generate the executable file.
1.2.3 Preprocessor Directives

Compiling a C program consists of multiple steps. The basic steps to creating an executable file are as follows:
1. The preprocessor prepares the source file so that the compiler can process the source code.
2. The compiler converts the source code to assembly language.
3. The assembler converts the assembly language to executable object code.
4. The linker integrates the executable object code modules into a single executable program file.
As step 1 indicates the preprocessor ensures that the compiler can process the source code. Preprocessor directives
provide the preprocessor with information that it needs to properly prepare the source file for the compiler.
Line 5 is one example of a preprocessor directive. The #include statement directs the preprocessor to include
information that is not contained within the HELLO.C file itself but that the executable program will require.
1.2.4 Header Files

Many of the functions used in C are contained in library modules. The #include preprocessor directive is used to
specify the header files required to access and use these functions. In Line 5, the #include directive specifies that the
preprocessor is to access and include information in the stdio.h file so that HELLO.C can access and use the printf()
2
Section 1 - Hello, World
function. Information that a header file provides are the names of C functions that the program can access, the values
(if any) that the functions return, and the parameters (if any) that are passed so that the function can process them.
Information about functions in a header file are called function prototypes. The following shows the prototype for
the printf() function in a stdio.h header file.
int _RTLENTRY _EXPFUNC printf(const char * __format, ...);
A full explanation of this prototype is beyond the scope of this tutorial. For now, all you need to know is that the
function printf() can return an integer (int) value and can accept a string (const char *), among other things, as a
parameter to process.
1.2.5 The Main Function

Lines 7 through 10 comprise the main body of the program, called (logically enough) main(). The main function is
the entry point into the C program, and when it finishes the C program ends. As with any other function main() can
return a value and accept parameters to process, although many C programs use neither. In HELLO.C the value void
at the beginning of Line 7 indicates that the program will ignore any value that the HELLO.C program returns.
Similarly, the empty parentheses in main ()indicates that no parameters are being passed to the program for it to
process. Placing the word void within the parentheses would indicate the same thing as leaving the parentheses
empty.
Lines 8 and 10 contain curly brackets (or braces) that contain the body of code for the main() function. The left curly
bracket (“{“) indicates the start of code, and the right curly bracket (“}“) indicates the end of code. In this case the
only line of code for main() is the printf() statement on Line 9. When the HELLO program runs, it enters the main()
function, executes the printf() function, and ends.
1.2.6 The printf() Function

Line 9 contains the printf() function, which is the only real line of code in the entire HELLO.C program. Although
printf() can return a value, the HELLO.C program ignores it simply by not assigning it to anything. If you ever wish
to use the return value of printf() (or any other function), you would assign it to a variable as shown below.
retval = printf (“Hello, world\n”);
For the example above, because printf() returns an integer value retval also must be an integer data type. You will
learn more about data types and functions in later chapters.
A point to note is that the line of code in Line 9 ends with a semicolon. Every line of code in C must end with a
semicolon, although as HELLO.C shows not every program line requires one. Lines that do NOT end in a semicolon
include comments, preprocessor directives, and function bodies like main(). In later chapters you will learn more
about the rules for writing C code.
1.2.7 Coding Style

Every programmer has his or her own coding style, and C is extremely tolerant about how you chose to structure
your code. In general, there are two basic coding styles.
The first style is the structured style that is widely used in structured programming languages like Pascal and
Modula 2. The HELLO.C listing uses the structured style. An advantage of the structured style is that it is very easy
to match the beginning and end of code blocks because they are equally indented, as are Lines 8 and 10 of the
HELLO.C listing. This helps to ensure that curly brackets are always paired and makes blocks of code, especially
nested blocks of code, easier to identify. A disadvantage of this method is that each new level of indentation leaves
less space for each line of code so that code can become harder to read and edit.
The second style, sometimes called the C style, is a more compact form. The HELLO.C listing in this style would
look similar to the following.
3
1 // HELLO.C
2
3 /* Your first C program */
4
5 #include <stdio.h>
6
7 void main (){
8 printf ("Hello, world\n");}
As you can see, the left curly bracket appears at the end of the function statement and the right curly bracket appears
at the end of the last line of the function body, rather than each curly bracket having a line of its own. This reduces
the number of lines needed for the program listing, but can make the code harder to read.
For clarity this tutorial will use the structured programming style. Which coding style you chose to use is a matter of
personal preference, but you should attempt to be consistent with whichever style you choose.
1.3 Conclusion
The HELLO.C program is a very simply program, but contains a good deal of information about the nature and
characteristics of C programs. The printf() function allows programs to output information. In the next section you
will learn about the data types, or the types of information with which C can work.
4
Section 2 - Elementary Data Types
2. Elementary Data Types

2.1 Overview
The first computers were designed to process numerical data, such as calculating tables of values or finding
solutions to very complicated calculations. It was only natural that many of the first programming languages, such as
FORTRAN (for “FORmula TRANslation”), were designed primarily to work with numbers. The introduction of the
personal computer changed the role of computers, allowing users to work not just with numbers but text, graphics,
and other types of information as well. Programming languages like BASIC and C also changed to support these
data types and allow programmers to more easily work these types of information. In this chapter you will learn
about the basic data types supported in C. In later chapters you will learn about other data types that are based on
these basic data types.
2.2 Elementary Data Types in C

All computers ultimately work with binary data values, so it should be no surprise that numeric types make up a
large part of the data types in C. Even data types that are not strictly numeric, such as characters, are stored as binary
values and can be represented in C as numbers. Because all data is ultimately binary in nature data types in C really
deal more with how programs represent and operate on data rather than the actual nature of the data.
Note that C has restrictions on valid variable names. As a rule, any variable name that begins with an upper- or
lower-case letter and contains only upper- or lower-case letters, numbers, and underscores (_) are valid.
2.2.1 Integers
The integer data type deals with numbers that have no fractional portion. For example, 5 and 1000000 are integers,
but 0.5 and 3.1416 are not. In C there are three basic types of integer data types: short int, int and long int.
The short int, or short, data type, is rarely used in C because it is often the same as the int data type. A short int
variable named short_var is declared using a statement similar to that below.
short int short_var; /* “short short_var;” is also acceptable */
On most computer systems the int data type represents numbers that are 16 bits long although this can vary with the
compiler. The int type can be either signed or unsigned, depending upon whether the data can be both positive and
negative (signed) or positive only (unsigned). The value of an unsigned int can be from 0 to +65,535 and that of a
signed int can be from –32,768 to +32,767. An int variable named int_var is declared using a statement similar to that
below.
int int_var;
The long int, or long, data type typically represents numbers that are 32 bits long. As with the int data type the long
int can be signed (positive or negative) or unsigned (positive only). The value of an unsigned long int can be from 0
to 4, 294,967,296 and that of a signed long int can be from –2,147,483,648 to +2,147,483,647. A long int variable
named long_var is declared using a statement similar to that below.
long int long_var; /* “long long_var;” is also acceptable */
One useful characteristic of integers is that C can readily copy values between different integer types provided that
the variable to which the data is being passed has more bits than the variable from which the data is being passed. In
other words, the value in int_var can be copied to long_var because long_var is 32-bits long and int_var is only 16 bits
long. Attempting to copy the value in long_var into int_var will create problems because a 16-bit variable cannot hold
a 32-bit value.
5
2.2.2 The char Data Type
The char data type, which represents 8-bit values, is actually an integer data type but is rarely used as an integer. As
the name suggests, variables of type char usually hold ASCII characters. This is useful for programs to store and
operate on single key presses, such as when a user must select an item from a number list or respond to a question
that requires an answer of Y (for yes) or N (for no). C uses single quotes to identify a char value, so the value ‘5’ is
the character for five whereas 5 is the numeric value five. A char variable named keypress is declared using a
statement similar to that below.
char keypress /* A variable to hold a single keypress */
Because the char data type has fewer bits than any other integer data type, char values can be copied into other
variables of other integer data types, but other integer value can be copied into a variable of char data type.
2.2.3 Floating Point Values

The floating point data type deals with numbers that have a fractional portion. For example, 2.7183 and 1.414 are
floating point values, but 111111111 and 123456 are not. Note that the fractional portion of a floating point value
can be zero, so that 2 is an integer value but 2.0 is a floating point value. In the real world the two values may be the
same, but they are different in C and are not interchangeable. In addition to representing numbers with fractional
parts, floating point values greatly extend the range of numbers that computers can process. In C there are two basic
types of floating point data types: float and double.
The float data type represents floating point values as 32-bit single-precision numbers defined by the ANSI floating
point standard, in which one bit represents the sign, eight bits represents the binary exponent, and the remaining
twenty-three bits represents the 24-bit mantissa (the most significant bit of the mantissa is always assumed to be 1).
32-bit float values range from about ±1.8 × 10–38 to ±3.4 × 10+38, compared to approximately 0 to ±2.1 × 109 for 32-
bit long int values. A float value named float_var is declared using a statement similar to that below.
float float_var /* Single-‐precision floating point value */
The double data type represents floating point values as 64-bit double-precision numbers defined by the IEEE
floating point standard, in which one bit represents the sign, eleven bits represents the binary exponent, and the
remaining fifty-two bits represents the 53-bit mantissa (the most significant bit is always assumed to be 1). The
additional exponent bits increase the range and the additional mantissa bits increase the accuracy of the 64-bit
double-precision value compared to the 32-bit single-precision numbers. 64-bit double values range from about
±2.2 × 10–308 to ±1.8 × 10+308. A double value named double_var is declared using a statement similar to that below.
double double_var /* Double-‐precision floating point value */
2.3 Other Data Types

In addition to the elementary data types, C supports extended data types that will be introduced and discusses in later
chapters. These include arrays (collections of identical data types treated as single entities), structures (collections of
different data types treated as single entities), and enumerated types (variables that can assume a limited set of user-
specified values). A special type of array, called the string data type, was not part of the original C standard but is
supported by many popular compilers and will be covered separately.
6
Section 3 - Input and Output
3. Input and Output

3.1 Overview
For computers to process data their users must have some means of supplying information for the computer to
process (called the input) and retrieving the processed data (called the output). C provides a number of functions for
program input and output. The printf() function, which you saw in Chapter 1, is an example of an output function
and is typically used to output information to the computer monitor. In this chapter you will learn more about
printf() and scanf(), the corresponding output function.
3.2 The scanf() Function

Just as the printf() function outputs data to the computer’s standard output device (the monitor) the scanf() function
inputs data from the computer’s standard input device (the keyboard). As its name suggests, the scanf() function
“scans” the stream of input entered from the keyboard and places that input in variables that the computer can
process. Because the keyboard input is a sequence of binary values, the scanf() function must specify the meaning of
that data – such as whether it is an char, int, float, etc. – and the variable into which that data should be placed so that
the program can properly process it. The scanf() function has a large number of options, called format specifiers, to
do so but for simplicity this chapter will present only the most basic operation of the scanf() function.
3.2.1 The Basic scanf() Format

The most basic format of the scanf() function is
scanf (“%<variable type>”, &<variable>)
where <variable type> is a character that specifies the data type of the variable and <variable> specifies the name of
the variable into which the scanf() function will place the input data. Some of basic allowed variable types for
scanf() are
c ASCII character value

d Signed decimal integer value
D Signed decimal long integer value
e Float value using exponents
f Float value
lf Double value
o Octal integer value
O Octal long integer value
u Unsigned decimal integer value
U Unsigned decimal long integer value
x Hexadecimal integer value
X Hexadecimal long integer value
Note that the data type of the specified variable must be of the same as that of the variable type.
3.2.2 Using the scanf() Function

Information for the scanf() function is located in the stdio.h file, so programs that use the scanf() function must use a
#include statement to specify this. In addition, the program must declare a variable into which the scanf() statement
will place the information. The following is an example of a program that will allow the user to enter an integer into
the variable number. Note that the program also uses the basic printf() function.
7
#include <stdio.h> /* Required for printf() and scanf() functions */

void main (void)
{
int number;

printf (“Please enter an integer value: ”);
scanf (“%d”, &number);
}
The scanf() function can input more than one input value at a time, which can be the same or different data types.
The program below shows how scanf() inputs two values into the variables number1 and number2.

void main (void)
{
int number;
char keypress;

printf (“Please enter an integer value and a character: ”);
scanf (“%d %c”, &number, &keypress);
}
This program allows the user to input an integer, but at this point have no practical value. First, the programs do
nothing with the information the user enters. Second, they don’t allow the user even to verify that the program input
the data correctly. In the next section you will learn more about the printf() function that can address both these
issues.
3.3 The printf() Function

Although Chapter 1 introduced the printf() function, which the program example also used in Section 3.2.2, this was
the most basic form of the function that did nothing more than output a fixed string of characters. The printf()
function can also output variable values in much the same way as the scanf() function inputs them. In addition,
however, it can mix those output variables with fixed strings of characters to help clarify the output.
3.3.1 The Basic printf() Format

You have already seen the most basic format of the printf() function that outputs a string of characters. The most
basic format of the printf() function that output the value of a variable is
printf (“%<variable type>”, <variable>)
where <variable type> is a character that specifies the data type of the variable and <variable> specifies the name of
the variable into which the printf() function will place the input data. Some of basic allowed variable types for
printf(), which are similar to those for the scanf() function, are
c ASCII character value
8
d Decimal integer value
e Float value using exponents
f Float value
o Octal integer value
u Unsigned decimal integer value
x Hexadecimal integer value using lower case characters for a, b, c, d, e, and f
X Hexadecimal integer value using upper case characters for A, B, C, D, E, and F
Note that the data type of the specified variable must be of the same as that of the variable type.
Because printf() is an output function it offers options for formatting how values are displayed on the screen. These
include whether it displays the sign of the value, the number of decimal places for float values, whether the value is
right or left justified, and the number of characters used to print the value including leading zeros or trailing blanks
if required. Some examples of these are shown below.
d Use as many spaces as necessary to print the integer, printing the sign only if the integer is
negative.
6d Use six spaces to print a right-justified signed integer, printing the sign only if the integer is
negative
–6d Use six spaces to print a left-justified signed integer, printing the sign only if the integer is
negative
+6d Use six spaces to print a right-justified signed integer, printing the sign for both positive and
negative values
–+6d Use six spaces to print a left-justified signed integer, printing the sign for both positive and
negative values
6.2f Use six spaces to print a right-justified float value, using two digits for the fractional portion.
–6.2e Use six spaces to print a left-justified float value using exponential notation, using two digits for
the fractional portion.
The printf() function also recognizes certain special characters to help format lines. One of these is the \n (newline)
character, which moves the cursor to the beginning of the next line on the screen. Another is the \t (tab) character,
which acts like the tab character on a computer keyboard and moves the cursor a fixed number of spaces to the right.
3.3.2 Using the printf() Function

Information for the printf() function is located in the stdio.h file, so programs that use the printf() function must use a
#include statement to specify this. In addition, the program must declare and initialize the variable that the printf()
statement will print to the screen. The following is an example of a program that initializes the integer and float
variables int_var and float_var and prints them to the screen.

#include <stdio.h> /* Required for printf()functions */

void main (void)
{
int int_var = 123;
float float_var = 123.4

printf (“Integer = %3d and float = %5.1f\n”, int_var, float_var);
}
When this program is compiled and run it will output the following:
9
Integer = 123 and float = 123.4
If the program must output signed values and use exponential notation for the float value, it can be modified as
shown below.

#include <stdio.h> /* Required for printf()functions */

void main (void)
{
int int_var = 123;
float float_var = 123.4

printf (“Integer = %+4d and float = %+6.1e\n”, int_var, float_var);
}
When compiled and run, the program will output the following:
Integer = +123 and float = +123.4
Note that the number of spaces for the integer and float values were both increased by one to add a space for
printing the sign.
3.4 Combining the scanf() and printf() Functions

The scanf() and printf() functions can be used together to verify with the printf() function that values entered into a
program with the scanf() function yield the correct values. Because these functions also permit data to be entered
and displayed in different formats, they can also be combined to create an interesting utility to convert values
between number systems.
3.4.1 Verifying scanf() with printf()

To use the printf() function to verify values entered with the scanf() function, the printf() function simply specifies
the scanf() variables as the printf() variables with any string of characters to clarify the output. As an example, the
scanf() program to enter an integer and character could be modified as shown below.

void main (void)
{
int number;
char keypress;

printf (“Please enter an integer value and a character: ”);
scanf (“%d %c”, &number, &keypress);
printf (“The integer you entered was %d\n”, number);
printf (“The character you entered was %c\n, keypress”);
}
10
3.4.2 Using scanf() and printf() to Convert Numbers
A somewhat creative use of the scanf() and printf() functions is to convert numbers between decimal, octal, and
hexadecimal by inputting one variable type and printing anther. As an example, a program to convert integers from
decimal to octal is shown below. Recall that the int data type is a 16-bit signed value. This means that number must
be between -32,768 and +32,767 (the range for signed 16-bit values). To convert larger integer values number must
be declared as a long data type.

void main (void)
{
int number;

printf (“Please enter a decimal integer value: ”);
/*
Use %d to enter the integer as decimal with scanf() and %o to print
the value as octal with printf().
*/
printf (“\nThe octal value is %o\n”, number);
}
If the decimal number entered is 100 the program will output the following:
Please enter a decimal integer value: 100

The octal value is 144
Similarly, a program to convert hexadecimal values into decimal is show below.

void main (void)
{
int number;

printf (“Please enter a hexadecimal integer value\n”);
printf (“(Use lower case for a through f): “);
/*
Use %x to enter the integer as hexadecimal with scanf() and %d to print
the value as decimal with printf().
*/
scanf (“%x”, &number);
printf (“\nThe decimal value is %d\n”, number);
}
If the hexadecimal number ffff is entered the program will output the following:
11
Please enter a hexadecimal value
(Use lower case for a through f): ffff
The decimal value is -1

Note that in this case the hexadecimal value ffff (or 1111 1111 1111 11112) is the 16-bit 2’s complement form of
–1, which is why the program displays the decimal value as –1. This shows that C represents negative numbers in
2’s complement form.
The programs to perform other conversions, such as hexadecimal to octal or decimal to hexadecimal, are very
similar to those above. The only changes that need be made are to the variable type in the scanf() and printf()
statements.
12
Section 4 - Arithmetic Operators
4. Arithmetic Operators
4.1 Overview
Functions are one way of processing data in C. Another way is to use C operators, which are part of the C language.
Operators are similar to functions, but are much more basic. Functions, such as printf(), consist of a series of
program statements that achieve some specific purpose such as outputting a string of text to the screen. Operators
and the values on which they operate form expressions that evaluate to some value. One operator with which you are
familiar from arithmetic classes is the addition (+) operator, which adds two numbers. The addition operator plus
two numbers evaluate to the sum of the tow numbers.
4.2 Arithmetic Operators in C

Arithmetic operations can operate on both integer and floating point values and use one or two operands. Operators
that use a single operand are called unary operators. Operators that use two operands are called binary operators.
When an operation, such as addition, uses two operands it is best always to use operands of the same data type.
Although C can and will evaluate expressions that contain different operand data types the results may not be what
you expected and cause your program to malfunction.
4.2.1 Unary Arithmetic Operators

The unary arithmetic operators in C consist of the following:
= Assignment
The assignment operator copies the value of the operand to the right of the = operator into the
operand to the left. The operand on the right can be a literal, variable, or expression, but the
operand on the left must be a variable. This means that a C statement that copies the sum of 2 and
3 into the variable sum is written
sum = 2 + 3;
and not
2 + 3 = sum;
the way arithmetic expressions are normally written.
-‐ Change sign
The change sign operator will convert a positive signed number to a negative signed number and
vice versa. The change sign operator operates on both actual numbers (called literals) and
variables. Note that although -‐5 indicates “negative five”, the expression –int_var does not
necessarily indicate a negative value. The expression –int_var means “the opposite of int_var”. If
the value of “int_var” is positive then the value of “-‐int_var” is negative, but if the value of
“int_var” is negative then the value of “-‐int_var” is positive.
++ Increment by one
The increment by one operator will increase the value of an integer variable by one. This operator
can be placed immediately before the operand for a pre-increment operation, or immediately after
the operand for a post-increment operation. A pre-increment operation changes the value of the
operand before the operand is used in a program statement, and a post-increment operation
changes the value of the operand after the operand is used in a program statement. As an example,
assume that the value of int_var is 7. Then
printf (“The number is %d.\n”, ++int_var);

printf (“The new number is %d.\n”, int_var);
will print
13
The number is 8.
The new number is 8.
This is because the pre-increment operation causes C to increment the value of int_var before
passing it to the first printf() function. Conversely,
printf (“The number is %d.\n”, int_var++);

printf (“The new number is %d.\n”, int_var);
will print
The number is 7.

The new number is 8.
This is because the post-increment operation causes C to increment the value of int_var after
passing it to the first printf() function.
Although the increment by one operator can be used with float values, rounding errors with float
values will affect the result. For example, incrementing the float value 8.0 could give a result of
8.99999 or 9.00001 rather than exactly 9.0. Consequently the increment by one operator should be
used only with integer values.
-‐-‐ Decrement by one
The decrement by one operator is similar to the increment by one operator except that this operator
will decrease the value of an integer variable by one. This operator also can be placed immediately
before the operand for a pre-decrement operation, or immediately after the operand for a post-
decrement operation.
As with the increment by one operator, the decrement by one operator should be used only with
integer values.
4.2.2 Binary Arithmetic Operators

Binary arithmetic operators in C use two operands. Arithmetic expressions in C always places the operator between
the two operands, just as standard arithmetic expressions do. As an example, the expression to add the variable
int_var and the number 3 would be
int_var + 3
The binary arithmetic operators in C consist of the following:

+ Addition
The addition operator will give the sum of the two operands.
-‐ Subtraction
The subtraction operation will give the difference of the two operands.
* Multiplication
The multiplication operation will give the product of the two operands.
/ Division
The division operation will give the quotient of two floating point operands or the integer portion
of the quotient of two integer operands.
% Modulus
14
The modulus operation will give the remainder when of one integer is divided into another. As an
example, the value of
14 % 5
is 4, because 5 divides evenly into 14 twice with a remainder of 4.
4.3 Order of Arithmetic Operations in C

C evaluates expressions from left to right using the following default order of operations:
++, -‐-‐ Increment and decrement by one operators

*, /, % Multiplication, division, and modulus operators
+, -‐ Addition and subtraction operators
Expression can use parentheses to alter the default order of operations. For example, C would normally evaluate the
expression
2 * 3 + 4 * 5
from left to right and complete the multiplication operations before the addition operation. This would give
2 * 3 + 4 * 5
6 + 4 * 5
6 + 20
26

However, C would evaluate the expression
2 * (3 + 4) * 5
by first completing the addition in parentheses and then evaluating the expression from left to right. This would give
2 * (3 + 4) * 5
2 * 7 * 5
14 * 5
70
4.4 Some Programming Examples with Arithmetic Operators

The following program demonstrates the results for the various arithmetic operators on both integers and floating
point values to illustrate how the operators function.
4.4.1 Demonstration of Arithmetic Operations

This program demonstrates the operation of the C unary and binary arithmetic operations.

void main (void)
15
{
int int_1, int_2, result;
float float_1, float_2;

/*
Input integer values
*/
printf (“Please enter integer 1: ”);
scanf (“%d”, &int_1);
printf (“\nPlease enter integer 2: ”);
scanf (“%d”, &int_2);
result = int_1 + int_2;
printf (“\nThe sum is %d: ”, result);
result = int_1 -‐ int_2;
printf (“\nThe difference is %d: ”, result);
result = int_1 * int_2;
printf (“\nThe product is %d: ”, result);
result = int_1 / int_2;
printf (“\nThe integer quotient is %d: ”, result);
result = int_1 % int_2;
printf (“\nThe integer remainder is %d: ”, result);
result = int_1++;
printf (“\nThe incremented value of integer 1 is %d: ”, result);
result = int_2-‐-‐;
printf (“\nThe decremented value of integer 2 is %d: ”, result);

/*
Skip two lines for spacing
*/
printf (“\n\n”);

/*
Input floating point values
*/
printf (“Please enter floating point 1: ”);
scanf (“%f”, &float_1);
printf (“Please enter floating point 2: ”);
scanf (“%f”, &float_2);
printf (“\nThe sum is %f: ”, float_1 + float_2);
printf (“\nThe difference is %f: ”, float_1 – float_2);
printf (“\nThe product is %f: ”, float_1 * float_2);
printf (“\nThe quotient is %f: ”, float_1 / float_2);
printf (“\nThe incremented value of floating point 1 is %f: ”, float_1++);
printf (“\nThe decremented value of floating point 2 is %f: ”, float_2-‐-‐);
}
16
Assume that the value of int_1 is 2, the value of int_2 is 3, the value of float_1 is 2.0, and the value of float_2 is 3.0
the program will output the following:
Please enter integer 1: 2

Please enter integer 2: 3

The sum is 5
The difference is -‐1
The product is 6
The integer quotient is 0
The integer remainder is 2
The incremented value of integer 1 is 3
The decremented value of integer 2 is 2

Please enter integer 1: 2.0
Please enter integer 2: 3.0

The sum is 5.00000
The difference is -‐1.000000
The product is 6.000000
The integer quotient is 0.666667
The incremented value of integer 1 is 3.000000
The decremented value of integer 2 is 2.000000

One item to note is how the value of the expressions are handled for the integer and floating point sections of the
program. In the integer section of the program the value of the expression first is assigned to a variable named result
and the printf() function then prints the value of result. In the floating point section the printf() functions print the
value of the expressions directly. This is because every expression evaluates to some value, and that value can be
assigned to a variable or C can use the value directly in functions or other expressions.
4.4.2 Quadratic Formula Evaluation

The second program evaluates the quadratic formula ax2 + bx + c by having the user first input the values of the
coefficients a, b, and c and then having the user input a value of x.

void main (void)
{
float a, b, c, x;
float answer;

/*
Input floating point value
*/
printf (“Please enter coefficient a: ”);
scanf (“%f”, &a);
printf (“Please enter coefficient b: ”);
17
scanf (“%f”, &b);
printf (“Please enter coefficient c: ”);
scanf (“%f”, &c);

/*
Input values of variable
*/
printf (“Please enter the value of variable x: ”);
scanf (“%f”, &x);

/*
Calculate the result of the quadratic equation
*/
answer = a*x*x + b*x + c;
printf (“\n\nThe answer is %f\n”, answer);
}
Assume that a = –1.5, b = 3.1, c = 0.7, and x = 5.0. The program will output the following:
Please enter coefficient a: –1.5

Please enter coefficient b: 3.1
Please enter coefficient c: 0.7
Please enter coefficient x: 5.0

The answer is -‐21.300001

Note that the answer is not exactly –21.3, which is the answer a calculator would give. This is because the binary
number system cannot represent decimal floating point numbers exactly. One solution would be to modify the
printf() statement so that it limits the fractional portion only to one digit.
printf (“\n\nThe answer is %4.1f\n”, answer);

This will have the program prints the answer as -‐21.3. Another solution would be to change the data type of the
variables a, b, c, and x from float to double for higher precision in the calculation.
4.5 Convenient Operator Shortcuts

A binary arithmetic expression does not automatically change the value of an operand. For example, assume that the
value of int_val is 12. The expression
int_val * 6
evaluates 72, but this value doesn’t change the value of int_val. In fact, the expression doesn’t change anything
unless an = assignment operator copies the value of the expression into some variable or a function accesses the
value. If the value of int_val actually must be multiplied by 6, the C expression to do so is
int_val = int_val * 6;
18
These kinds of operation, in which the value of an expression is copied into one of the operands, occur very often in
C so C provides special shortcut operators for them. These operators append the = assignment operator to the
arithmetic binary operators, so the shortcut operator for addition is +=, the shortcut operator for division is /=, and so
forth. Expressions that use these special operators place the operand to be changed on the left of the operator and the
operand that will change them on the right. As an example, an equivalent C expression uses the shortcut operator to
multiply the value of int_val by 6 is
int_val *= 6;
Similarly, an expression that is equivalent to loop++ and increases the value of loop by one is
loop += 1;
because this is equivalent to
loop = loop + 1;
One useful expression that multiplies a variable (called squared in this example) by itself is
squared *= squared;
Shorthand operators are not limited to just binary arithmetic operators. As the next chapter shows shorthand
operators exist for binary logical operators as well.
19
Section 5 - Logic Operators
5. Logic Operators
5.1 Overview
The last section discussed the basic arithmetic operators in C that allow programs to work with numbers and
equations. Another set of operators are the logic operators. These operators allow programs to work with Boolean
values and expressions. They also allow programs to examine and manipulate the individual bits in binary values.
This powerful C feature is quite important for allowing processors to test and control individual control lines in
digital systems.
5.2 Logic Operators in C

Logic operators can operate only on integer values, but like arithmetic operators can use one or two operands.
Unlike arithmetic operators, logic operands can be an entire integer value or the individual bits of an integer value.
Typically “logic operator” means that the operation involves integer values as a whole, whereas “bitwise operator”
means that the operation involves individual bits of integer values.
Logic expressions always evaluate to one of two integer values, call Boolean values. These two values are 0 (or
FALSE) and not 0 (or TRUE). Many times program use 1 to represents a TRUE value, although any non-zero
integer can represent a TRUE value.
5.2.1 Unary Logic Operators

Only one unary logic operator exists in C, which is detailed below.
! Logic NOT (Inverter)
The logic NOT operator, represented by an exclamation point (sometimes pronounced “bang” by
old-time C programmers), corresponds to a digital inverter and will invert a logical value from
TRUE to FALSE or from FALSE to TRUE. The logic NOT operator is placed immediately
before the value to be inverted. Assume that the value of logic_var is FALSE. The expression that
inverts logic_var is
!logic_var
Note that, as with arithmetic operators, this does not change the value of the operand. An
assignment operator must be used to copy the value of the evaluated expression into another
variable. A statement that will copy the inverse of logic_var into a variable called bool_var is shown
below:
bool_var = !logic_var;
The logic NOT is always evaluated first in an expression, unless parentheses change the standard order of
operations. The following program demonstrates how the logical NOT operator functions.

include <stdio.h> /* Required for printf() function */

void main (void)
{
int false_val = 0,
true_val = 1;

printf (“false_val = %d, !false_val = %d\n”, false_val, !false_val);
printf (“true_val = %d, !true_val = %d\n”, true_val, !true_val);
21

}
When run, this program will output the following:
false_val = 0, !false_val = 1

true_val = 1, !true_val = 0
5.2.2 Binary Logical Operators

Binary logic operators in C use two operands. Logic expressions in C always place the operator between the two
operands, just as with arithmetic expressions in C. As an example, an expression to AND the variable logic_var and
the decimal number 3 would be
logic_var && 3
The binary logic operators in C consist of the following:

&& Logic AND
The logic AND operator will produce a TRUE or FALSE value according to the following rules.
• If both operands are TRUE (not 0), the value of the expression is TRUE.
• If either or both operands are FALSE (0), the value of the expression is FALSE.
Assume, for example, that logic_var = 1 and bool_var = 0. Then
logic_var && bool_var
is FALSE, because one of the variables (bool_var) is FALSE. On the other hand,
logic_var && !bool_var
is TRUE because both logic_var and !bool_var (the inverse of bool_var) are TRUE.
The following program demonstrates how the logic AND operator functions.

#include <stdio.h> /* Required for printf() function */

void main (void)
{
int false_val = 0,
true_val = !false_val;

printf (“A = %d, B = %d, A && B = %d\n”, false_val, false_val,
false_val && false_val);
printf (“A = %d, B = %d, A && B = %d\n”, false_val, true_val,
false_val && true_val);
22
printf (“A = %d, B = %d, A && B = %d\n”, true_val, false_val,
true_val && false_val);
printf (“A = %d, B = %d, A && B = %d\n”, true_val, true_val,
true_val && true_val);
}
When run, this program will output the following truth table for the logical AND function:
A = 0, B = 0, A && B = 0

A = 0, B = 1, A && B = 0
A = 1, B = 0, A && B = 0
A = 1, B = 1, A && B = 1
Note that true_val was initialized as !false_val when it was declared as an int variable rather than as the literal value
of 1. This is acceptable in C provided that false_val has been properly initialized already.
|| Logic OR
The logic OR operator will produce a TRUE or FALSE value according to the following rules.
• If both operands are FALSE (0), the value of the expression is FALSE.
• If either or both operands are TRUE (not 0), the value of the expression is TRUE.
Assume, for example, that logic_var = 0 and bool_var = 0. Then
logic_var || bool_var
is FALSE, because both variables (logic_var and bool_var) are FALSE. On the other hand,
!logic_var || bool_var
is TRUE because at least one of the operands (!logic_var, the inverse of logic_var) is TRUE.
The following program demonstrates how the logic OR operator functions.

#include <stdio.h> /* Required for printf() function */

void main (void)
{
int false_val = 0,
true_val = !false_val;

printf (“A = %d, B = %d, A || B = %d\n”, false_val, false_val,
false_val || false_val);
printf (“A = %d, B = %d, A || B = %d\n”, false_val, true_val,
false_val || true_val);
printf (“A = %d, B = %d, A || B = %d\n”, true_val, false_val,
23
true_val || false_val);
printf (“A = %d, B = %d, A || B = %d\n”, true_val, true_val,
true_val || true_val);
}
When run, this program will output the following truth table for the logic OR function:
A = 0, B = 0, A || B = 0

A = 0, B = 1, A || B = 1
A = 1, B = 0, A || B = 1
A = 1, B = 1, A || B = 1
5.3 Bitwise Operators in C

Bitwise operators, as with logic operators, use only integer values but operate on and affect the individual bits of
operands. Bitwise operators always required two operands. Bitwise operators allow programmers to selectively test,
set, clear, invert, and shift bits, which is very useful when working with digital hardware. As an example, bitwise
operators allow programs to determine the value of individual data lines on an input port, or light a specific LED of
an LED bank attached to an output port.
5.3.1 Bitwise Logic Operators

Bitwise logic operators in C implement digital logic functions like logic operators, but apply the functions to
corresponding bits of the operands rather than the operands as a whole. As an example, bitwise ORinging the int
hexadecimal values 0x12 and 0xA5 (binary values 00010010 and 01011010, respectively) will do the following:
Bits 7: 0 OR 1 = 1
Bits 6: 0 OR 0 = 0
Bits 5: 0 OR 1 = 1
Bits 4: 1 OR 0 = 1
Bits 3: 0 OR 0 = 0
Bits 2: 0 OR 1 = 1
Bits 1: 1 OR 0 = 1
Bits 0: 0 OR 1 = 1
The result of bitwise ORing 0x12 and 0x5A is binary 10110111, or hexadecimal 0xB7. Note that cause bitwise logic
operations operate on corresponding bits of the operands, the size of the bitwise logic operands in C should be the
same integer size. Although C can apply bitwise logic operators to operands of different sizes, such as an int and a
long, this can produce unexpected results and should be avoided.
Bitwise expressions in C always place the operator between the two operands, just as with logical expressions in C.
As an example, an expression to bitwise AND the variable logic_var and the decimal number 3 would be
logic_var & 3
The bitwise logic operators in C consist of the following:
& Bitwise AND

The bitwise AND operator will AND the corresponding bits of two operands together and produce
bits according to the following rules.
24
• If both bits are 1, the value of the result bit is 1.

• If either or both bits are 0, the value of the result bit is 0.
Assume, for example, that op_1 = 0xF0 and op_2 = 0x55, or binary 11110000 and 01010101,
respectively. Then
op_1 & op_2
will produce the following result:
Bits 7: 1 AND 0 = 0
Bits 6: 1 AND 1 = 1
Bits 5: 1 AND 0 = 0
Bits 4: 1 AND 1 = 1
Bits 3: 0 AND 0 = 0
Bits 2: 0 AND 1 = 0
Bits 1: 0 AND 0 = 0
Bits 0: 0 AND 1 = 0
The result of bitwise ANDing 0xF0 and 0x55 gives the result 01010000 binary, or 0x50.
Note from the above example that ANDing a bit with 1 will preserve the value of a bit and ANDing a bit with 0 will
clear that bit. By using the correct bit mask, or pattern of 0s and 1s, programs can isolate specific bits in an integer
value and determine whether the bit is a 0 or 1 by removing, or masking off, all the other bits. One application of
masking off bits is to convert an ASCII value into a numeric value. When the ‘3’ key on a computer keyboard is
pressed, the keyboard does not send the number 3 to the computer. Instead, it sends the ASCII code for ‘3’. The part
of the operating system that processes number keys masks off bits in the ASCII code so that bits that remain are the
binary value of the number. As it happens, the ASCII value for the digits ‘0’ through ‘9’ are the hexadecimal values
0x30 through 0x39, or 00110000 through 00111001 respectively. To convert a number keypress from ASCII to an
integer value all that is necessary is to remove the upper four bits and preserve the lower four bits. The program
below shows how this can be done.

#include <stdio.h> /* Required for printf() and scanf() function */

void main (void)
{
char key;
int bitmask = 0x0F;

// Get a keypress
printf (“Enter a number key: ”);
scanf (“%c”, &key);

// Show the key that was entered.
printf (“You pressed the ‘%c’ key.\n”, key);
printf (“The ASCII value is 0x%2x\n”, key);

25
// Show the value of the key that was entered.
printf (“The value of the key is %d.\n”, key & bitmask);
}
Assume that you enter the value “4”. When run, this program will output the following:
Enter a number key: 4

You pressed the ‘4’ key.
The ASCII value is 0x34.
The value of the key is 4.
Note that the printf() statement that outputs key uses %c to output the value as an ASCII character, whereas the
printf() statement that outputs key & bitmask uses %2x to output the integer value as a 2-digit hexadecimal integer.
| Bitwise OR
The bitwise OR operator will OR the corresponding bits of two operands together and produce bits
according to the following rules.
• If both bits are 0, the value of the result bit is 0.

• If either or both bits are 1, the value of the result bit is 1.
Assume, for example, that op_1 = 0x81 and op_2 = 0x5A, or binary 10000001 and 01011010,
respectively. Then
op_1 | op_2
Bits 7: 1 OR 0 = 1
Bits 6: 0 OR 1 = 1
Bits 5: 0 OR 0 = 0
Bits 4: 0 OR 1 = 1
Bits 3: 0 OR 1 = 1
Bits 2: 0 OR 0 = 0
Bits 1: 0 OR 1 = 1
Bits 0: 1 OR 0 = 1
The result of bitwise ANDing 0x81 and 0x5A gives the result 11011011 binary, or 0xDB
hexadecimal.
Note from the above example that ORing a bit with 0 will preserve the value of a bit and ORing a bit with 1 will set
that bit. By using the correct bit mask programs can set, or mask on, specific bits in an integer value. One
application of masking on bits is to convert a numeric value into an ASCII value. Suppose, for example, that you
add two integer values and wish output the sum as an ASCII value. To convert an integer value between 0 and 9 all
that is necessary is to set the upper four bits to a hexadecimal 3, or 0011 binary. The program below shows how to
convert the sum of two integers to an ASCII value.
26


void main (void)
{
char key1, key2, sum;
char or_mask = 0x30,
and_mask = 0xF0;

// Get the two numbers to add.
printf ("Enter the first number: ");
scanf ("%c", &key1);
key1 = key1 & and_mask;
printf ("Enter the second number: ");
scanf ("%c", &key2);
key2 = key2 & and_mask;

// Add the two numbers.
sum = key1 + key2;

// Show the addition using integers.
printf ("The addition is %d + %d = %d.\n", key1, key2, sum);

// Convert the sum to ASCII.
sum = sum | bitmask;

// Show the value of the sum that was entered.
printf ("The sum is '%c'.\n", sum);
}

Assume that you enter the values “3” and “5”. When run, this program will output the following:
Enter the first number: 3

Enter the second number: 5
The addition is 3 + 5 = 8.
The sum is ‘8’.
You may have noticed, that contrary to earlier warnings, the numbers for this program are entered as 16-bit integers
but that the 16-bit value sum is output as an 8-bit ASCII character. When the C program is compiled and run, it
treats values of key1, key2, and sum as 16-bit integers, but when the printf() statement uses %c to reference sum as an
8-bit character it ignores the upper 8 bits and outputs only the lower 8 bits. In this example only the lower 8 bits are
important, so this is not a problem. However, the upper 8 bits may be significant in other applications so that
program would need to deal with them accordingly.
^ Bitwise XOR (Exclusive-OR)

The bitwise logic XOR operator will exclusive-OR the corresponding bits of two operands
together and produce bits according to the following rules.
27
• If both bits are different Boolean values, the value of the result bit is 1.
• If both bits are the same Boolean value, the value of the result bit is 0.
Assume, for example, that op_1 = 0x0F and op_2 = 0xAA, or binary 00001111 and 10101010,
respectively. Then
op_1 ^ op_2
Bits 7: 0 XOR 1 = 1
Bits 6: 0 AND 0 = 0
Bits 5: 0 AND 1 = 1
Bits 4: 0 AND 0 = 0
Bits 3: 1 AND 1 = 0
Bits 2: 1 AND 0 = 1
Bits 1: 1 AND 1 = 0
Bits 0: 1 AND 0 = 1
The result of bitwise ANDing 0x0F and 0xAA gives the result 10100101 binary, or 0xA5
hexadecimal.
Note from the above example that XORing a bit with 0 will preserve the value of a bit and XORing a bit with 1 will
invert that bit. By using the correct bit mask, or pattern of 0s and 1s, programs can selectively invert bits in an
operand. One use of the bitwise logic XOR operation is to produce the 1’s complement of an integer value. XORing
an integer with itself will always result in 0, so using the XOR operator is one way to initialize a variable to 0. The
bitwise XOR is often used in generating checksums and in cyclic redundancy checks, which are ways for software to
verify that data has not been corrupted. The following program illustrates a particularly interesting use of the bitwise
XOR function.


void main (void)
{
int number1, number2;

// Input two numbers.
printf (“Enter a number: ”);
scanf (“%d”, &number1);
printf (“Enter another number: ”);

// Show the numbers that were entered.
printf (“Number 1 = %d, Number 2 = %d.\n\n”, number1, number2);

// Hocus-‐pocus and alakazam...
number1 = number1 ^ number2;
28

// Presto!
printf (“Number 1 = %d, Number 2 = %d.\n”, number1, number2);
printf (“Your numbers have traded places!\n”);
}
Assume that you enter the numbers 17 and 36. When run, this program will output the following:
Enter a number: 17

Enter another number: 36
Number 1 = 17, Number 2 = 36.

Number 1 = 36, Number 2 = 17.
Your numbers have traded places!
While this may not seem impressive, the bitwise XOR allows programs to perform what is called an in-place
exchange. That its, a program can exchange two integer values without requiring a third variable as a temporary
storage location. This is a useful technique, especially in low-level programming, for swapping the contents of two
storage locations when an extra memory location or processor register is available.
5.3.2 Bitwise Shift Operators

Bitwise shift operators allow programmers to shift operands by one or more bits left or right, just as hardware shift
register shift data left or right. When operands shift to the left, C shifts a 0 into the least significant (rightmost) bit
position. When operands shift to the right, C shifts the sign bit into the most significant (leftmost) bit position. For
positive integers the sign bit is 0, and for negative integers the sign bit is 1.
The bitwise shift operators in C consist of the following:
<< Bitwise Shift Left

The bitwise shift left operator will shift the first integer operand to the left by the number of bits
indicated by the second operand. Assume, for example, that op_1 = 15 and op_2 = 3, or binary
00001111 and 00000011, respectively. Then
op_1 << op_2
will shift the value of op_1 to the left by three places as shown:
Shift 1: 00001111 → 00011110

Shift 2: 00011110 → 00111100
Shift 3: 00111100 → 01111000
The result of shifting 15 to the left by three places gives a result of 01111000 binary, or 120. Note
that because C shifts a 0 into the least significant bit position, continuing to shift an operand left
will eventually result in a value of 0.
One application of shifting left is to multiply a number by two. Notice for that above example that
shifting 15 left by three places gives the same result as doubling 15 three times:
29
15 × 2 = 30
30 × 2 = 60
60 × 2 = 120
Another use is to shift bits in an operand so that they sequentially appear in a specific bit position
and the program can use a single bit mask to evaluate them. The following program shows how
shifting and a bit mask can convert a decimal number into binary.


void main (void)
{
int number;
int bitmask = 0x80;

// Get a number.
printf ("Enter a number between 0 and 255: ");
scanf ("%d", &number);
printf ("%d decimal = ", number);

/*
Shift the number left by one. The value of the most significant bit is 128,
so divide the masked value by 128 to get a 1 or 0 for that bit.
*/

printf ("%d", (number & bitmask) / 128);
number = number << 1;
printf ("%d binary\n", (number & bitmask) / 128);
}
Assume that you enter the value “100”. When run, the program will output the following:
Enter a number: 100

100 decimal = 01100100 binary
30
>> Bitwise Shift Right
The bitwise shift right operator is similar to the bitwise shift left operator and will shift the first
integer operand to the left by the number of bits indicated by the second operand. The main
difference is that the value of the bit shifted into the most significant bit position is not always the
same. Assume, for example, that op_1 = +240 and op_2 = 4, or binary 11110000 with a sign bit of
0 and 00000100, respectively. Then
op_1 >> op_2
will shift the value of op_1 to the right by four places as shown:
Shift 1: 11110000 → 01111000

Shift 2: 01111000 → 00111100
Shift 3: 00111100 → 00011110
Shift 4: 00011110 → 00001111
The result of shifting 240 to the right by four places gives a result of 00001111 binary, or 15.
Continuing to shift to the value of the op_1 to the right will eventually result in a value of 0.
However, assume now that op_1 = –240, or binary 00010000 with a sign bit of 1. Then the shift
operation will give the following.
Shift 1: 00010000 → 10001000 (-

Shift 2: 10001000 → 11000100
Shift 3: 11000100 → 11100010
Shift 4: 11100010 → 11110001
The result of shifting –240 to the right by four places gives a result of 11110001, or –15 in 2’s
complement form. Note that because the sign bit is 1, continuing to shift a negative operand left
will eventually result in a value of all 1s.
5.4 Convenient Operator Shortcuts

Just as there are operator shortcuts for arithmetic operators, there are similar operator shortcuts for logical operators
that appends the = assignment operator to the logical operator. For example, the statement
op_1 &&= op_2;
is the same as
op_1 = op_1 && op2;
and
number |= bit_mask;
is the same as
number = number | bit_mask;

31
The one exception to this rule is for the logical NOT, or invert, operator. The statement
val_1 != val_2;
is NOT the same as
val_1 = val_1 ! val_2;
This should not be a surprise, as the ! operator is a unary operator, and shortcut operators apply only to binary
operations. However, != is an operator and does have a specific meaning in the C language, which the next chapter
on relational operators will cover.
32
Section 6 - Relational Operators
6. Relational Operators
6.1 Overview
Relational operators, like logic operators, produce Boolean results. That is, the result of a relational operator is either
FALSE (0) or TRUE (not 0). Programs can use relational operators simply to generate Boolean values, just as they
can use logic operators to generate Boolean values. However, C programs typically use relational operators to
control how programs operate.
6.2 Relational Operators in C

C uses relational operators to compare two values and determine the relationship between them. For example,
relational operators can determine whether or not two numbers are equal or, if not, which number is larger than the
other. Because comparisons between different things are meaningless (such as when trying to compare apples and
oranges), relational operators must use operands of the same type. Although C will allow relational operators to use
different data types, like comparing unsigned integers with signed integers or characters with doubles, the results of
these operations are typically meaningless.
The relational operators in C consist of the following:
== Equals Operator
The equals operator indicates whether or not two operands have the same value. If the two
operands have the same value the result is TRUE, and if not the result is FALSE. Sometimes the
result of an equals operator not what you might expect. Consider the results of the following
program.

void main (void)
{
int result;

result = (1.0 / 2.0) == 0.5;
printf ("(1.0 /2.0) == 0.5 => %d\n", result);

result = (1.0 / 10.0) == 0.1;
printf ("(1.0 /10.0) == 0.1 => %d\n", result);
}
This program determines whether the value of (1.0 / 2.0) is equal to 0.5, and whether the value of
(1.0 / 10.0) is equal to 0.1. When run, this program will output the following:
(1.0 / 2.0) == 0.5 => 1

(1.0 / 10.0) == 0.1 => 0
Although mathematically both statements are TRUE, computers must work with binary numbers and the precision
of floating point arithmetic in C is limited. The floating point value 0.5 (21/2) is an exact power of 2, so the
calculation (1.0 / 2.0) and the value 0.5 are equal and the expression (1.0 / 2.0) == 0.5 evaluates to a TRUE result.
However, 0.1 is not an exact power of 2, so the calculation (1.0 / 10.0) and the value 0.1 are not equal and the
expression (1.0 / 10.0) == 0.1 evaluates to a FALSE result.
33
Because English and arithmetic use “equals” and “=” to represent both equality and assignment, one common
mistake that beginning C programmers make is to use the assignment operator “=” instead of the equals operator
“==”. Most C compilers will issue a warning, such as “Possibly incorrect assignment in statement” when the context
of the statement calls for the equals operator rather than the assignment operator.
!= Not Equals Operator

The not equals operator indicates whether or not two operands have the same value, similar to the
equals operator, but the result will be FALSE if the operands are equal and TRUE if the operands
are not equal. The not equals operator has the same limitations with floating point precision as the
equals operator. The program below replaces the equals operator in the above program with the
not equals operator.

void main (void)
{
int result;

result = (1.0 / 2.0) != 0.5;
printf ("(1.0 /2.0) != 0.5 => %d\n", result);

result = (1.0 / 10.0) != 0.1;
printf ("(1.0 /10.0) != 0.1 => %d\n", result);
}
As you might expect, this program will output the following:
(1.0 / 2.0) != 0.5 => 0

(1.0 / 10.0) != 0.1 => 1
< Less Than Operator

The less than operator indicates whether or not the first operand is less than the second operand. If
the first operand is less than the second operand the result is TRUE, but if the first operand is
greater than or equal to the second operand the result is FALSE.

<= Less Than or Equal Operator
The less than or equal operator indicates whether or not the first operand is less than or equal to
the second operand. If the first operand is less than or equal to the second operand the result is
TRUE, but if the first operand is greater than the second operand the result is FALSE.
> Greater Than Operator

The greater than operator indicates whether or not the first operand is greater than the second
operand. If the first operand is greater than the second operand the result is TRUE, but if the first
operand is less than or equal to the second operand the result is FALSE.

>= Greater Than or Equal Operator
34
Section 6 - Relational Operators
The greater than or equal operator indicates whether or not the first operand is greater than or
equal to the second operand. If the first operand is greater than or equal to the second operand the
result is TRUE, but if the first operand is less than the second operand the result is FALSE.
6.3 Looking Ahead

As the overview indicated, most C programs use relational operators to control how programs operate. Specifically
the relational operators allow programs to make decisions about when and when not to execute specific statements.
This type of execution is called conditional execution, because whether or not statements execute depends upon
whether or not some condition or set of conditions is satisfied. The next section will introduce the how C programs
make decisions and conditionally execute statements.
35
Section 7 - Decisions and Conditional Execution
7. Decisions and Conditional Execution

7.1 Overview
The previous chapters introduced basic components of C, such as basic data types, functions, and operators, and
shown some simple programs that illustrate how C uses these components. These programs execute the same
sequence of statements each time that they are run, although the program input and output can vary. Programs like
these have very limited use because they can process information but not act on the information. In other words,
they cannot use information that is provided to them to decide what to do. Making decisions about which statements
to execute is called conditional execution, because the program must decide whether or not some condition or
conditions exist before executing statements.
C provides two basic conditional execution statements. The first is the IF...ELSE statement. The second is the SWITCH
statement, which is a specialized form of the IF...ELSE statement.
7.2 The IF...ELSE Statement

The IF...ELSE statement has the following form:
if (Boolean expression)
C statement 1;
else
C statement 2;
C statement 3;
If Boolean expression is TRUE the program executes C statement 1 and proceeds to C statement 3. If Boolean
expression is FALSE the program skips over C statement 1 to C statement 2 and proceeds to
C statement 3. The program below illustrates how the IF...ELSE statement works. Recall that % is the MOD operator.
#include <stdio.h> /* Required for the printf() and scanf() functions. */

void main (void)
{
int number;

printf (“Enter an integer: ”);
if ((number % 2) == 0)
printf (“The number %d is even.\n”, number);
else
printf (“The number %d is odd.\n”, number);
printf (“End of program.\n”);
}
Assume that the number entered is 24. When the program is run the output will be:
Enter an integer: 24

The number 24 is even.
End of program.
37
Suppose, however, that the number entered is 7. When the program is run the output will be:
Enter an integer: 7

The number 7 is odd.
End of program.
When the number entered is 24 (or any even number) the expression (number % 2) == 0 is TRUE because the
remainder of any even number divided by 2 is 0. The program executes the printf() statement in the IF portion of the
IF...ELSE statement to print “The number 24 is even.” and then skip the ELSE portion of the IF...ELSE statement to
print “End of program.”. When the number entered is 7 (or any odd number), the expression (number % 2) == 0 will
be FALSE, because the remainder of any odd number divided by 2 will be 1 and not 0. The program skips over the
IF portion of the IF...ELSE statement to execute the printf() statement in the ELSE portion of the IF...ELSE statement
and then print “End of program.”.
The Boolean expression in the program above uses both an arithmetic and relational operator to generate a Boolean
value. The program below shows another IF...ELSE statement that uses a relational operator.

void main (void)
{

printf (“Enter another integer: ”);
if (number1 < number2)
printf (“%d is less than %d.\n”, number1, number2);
else
printf (“%d is greater than %d.\n”, number1, number2);
}
Assume that the number1 is 9 and number2 is 5. When the program is run the output will be:
Enter an integer: 9

Enter another integer: 5
9 is greater than 5.
End of program.
Suppose now that number1 is 99 and number2 is 100. When the program is run the output will be:
Enter an integer: 99

Enter another integer: 100
99 is less than 100.
End of program.
38
In some cases a program may not require the ELSE portion of the IF...ELSE statement. In these cases, the ELSE
portion of the IF...ELSE statement is simply omitted. The following is an example of such a program.

void main (void)
{
int number;

if (number)
printf (“%d is non-‐zero.\n”, number);
number++;
printf (“The incremented value is %d.\n”, number);
}
Assume that the number entered is 3. When the program is run the output will be:
Enter an integer: 3

The number is non-‐zero.
The incremented value is 4.
If, however, the number entered is 0 program will output:
Enter an integer: 0

The incremented value is 1.
As you can see, the ELSE portion is included when the program must make a choice between and execute one of two
statement. The ELSE portion is omitted when the program simply executes an additional statement when it detects
some specified condition (for the above program, it indicates when a non-zero value is entered).
7.3 The SWITCH Statement

The IF...ELSE statement is good for when a program must choose between executing one of two statements.
Sometimes, however, a program must deal with several possible choices. In these cases the SWITCH statement is a
better choice. Whereas the IF...ELSE statement uses a Boolean value to choose one of two statements to execute, the
SWITCH statement uses an integer value to chooses between several possible statements to execute. The SWITCH
statement has the following form:
switch (integer value)

{
case integer value 1: C statement 1;
break;
case integer value 2: C statement 2;
break;
...
case integer value n: C statement n;
39
break;
default: default C statement;
}
The case portions of the switch statement are not themselves executed. Instead, they are simply entry points that
determine where the program will enter the switch program and begin execution. Note that each case statement ends
with a break statement. When the program encounters and executes the break statement, it exits the switch statement.
Most case statements use break statement, but as you will see sometimes omitting the break statement can simplify a
switch statement.
The number of alternatives (indicated by the number of case statements) theoretically is limited only by the number
of values that integer value can have. A char value is limited to 256 case statements plus the default statement,
whereas an unsigned long int value can have over 4 billion. The program below is an example of a SWITCH
statement.

void main (void)
{
char keypress;

printf (“Enter a letter: ”);
scanf (“%c”, &keypress);
printf (“The character ‘%c’ is a ”, keypress);
switch (keypress)
{
case ‘a’: printf (“vowel”);
break;
case ‘e’: printf (“vowel”);
break;
case ‘i’: printf (“vowel”);
break;
case ‘o’: printf (“vowel”);
break;
case ‘u’: printf (“vowel”);
break;
case ‘y’: printf (“vowel or consonant”);
break;
default: printf (“consonant”);
}
printf (“.\n”);
}
Assume that the letter entered is ‘e’. When the program is run the output will be:
Enter a letter: e
The character ‘e’ is a vowel.
40
If the letter entered is ‘y’, the program will output
Enter a letter: y
The character ‘y’ is a vowel or consonant.
It the letter entered is ‘z’, the program will output:
Enter a letter: z
The character ‘z’ is a consonant.
When the letter ‘e’ is entered, the program outputs “The character ‘e’ is a ” because that portion of the output is the
same regardless of the key pressed. The program then executes the switch statement and compares the value of
keypress (e) with the possible switch cases. The value of keypress is not ‘a’ so program skips the printf() and break
statements associated with that case statement and proceeds to the next case statement. This time the value of
keypress equals the value for the case ‘e’ statement, so the program executes the printf() statement to output “vowel”.
It then executes the break statement to exit the switch statement and outputs the ‘.’ to complete the output sentence.
When the letter ‘z’ is entered, the program outputs “The character ‘z’ is a ” that is output regardless of the key
pressed. The program then executes the switch statement and compares the value of keypress (e) with the possible
switch cases. The value of keypress does not match any of the case values, so the program skips the printf() and
break statements associated with each of them. After passing by all the case statements it then executes the printf()
associated with the default statement and outputs “consonant”. This takes it to the end of the switch statement, so it
exits the switch statement and outputs the ‘.’ to complete the output sentence.
One thing to notice about the program above is that the output for each case statement is the same. Rather than using
individual statements for each case statement, the program can use a single statement by eliminating the break
statements for the first four cases. The program shows how this is done.

void main (void)
{
char keypress;

switch (keypress)
{
case ‘a’:
case ‘e’:
case ‘i’:
case ‘o’:
case ‘u’: printf (“vowel”);
break;
case ‘y’: printf (“vowel or consonant”);
break;
default: printf (“consonant”);
}
printf (“.\n”);
41
}
This program produces the same output as for the previous program. If the keypress value is ‘a’, ‘e’, ‘i’, or ‘o’ the
program will enter the switch statement through case entry point and “fall through” to execute the statements
associated with the case ‘u’ statement because there is no break statement to force the program out of the switch
statement. If the keypress value is ‘u’ or ‘y’ the program will execute the printf() and break statements associated
with them as it normally would. If keypress has any other value the program will execute the default statement.
7.4 More About C Statements

7.4.1 Nested Statements
In the discussion of the IF...ELSE statement you learned that the program will execute the statement in the IF portion
it the Boolean expression evaluates to TRUE and the statement in the ELSE portion if the Boolean expression
evaluates to FALSE. Similarly, for a SWITCH statement the program executes all the statements that are associated
with an active CASE condition until it encounters a BREAK statement. C allows these statements to be additional
IF...ELSE and SWITCH statements. Placing IF...ELSE statements in an IF...ELSE statement, or SWITCH statements in a
SWITCH statement is called nesting. The program below shows how a nested IF...ELSE statement can replace the
SWITCH statement in the program that identifies whether a letter is a vowel or consonant.

void main (void)
{
char keypress;

if (keypress == ‘a’)
printf (“vowel”);
else
if (keypress == ‘e’)
else
if (keypress == ‘i’)
else
if (keypress == ‘o’)
else
if (keypress == ‘u’)
else
if (keypress == ‘y’)
printf (“vowel or consonant”);
else
printf (“consonant”);
printf (“.\n”);
42
}
Just as the first SWITCH program could be and was modified to use a single printf() function for vowels, the nested
IF...ELSE program can be modified to reduce the number of program lines. The program below is one possible
approach.

void main (void)
{
char keypress;

if ((keypress == ‘a’) ||
(keypress == ‘e’) ||
(keypress == ‘i’) ||
(keypress == ‘o’) ||
(keypress == ‘u’))
else
if (keypress == ‘y’)
printf (“vowel or consonant”);
else
printf (“consonant”);
printf (“.\n”);
}
The program uses the logical OR operator in the Boolean expression of the top-level IF...ELSE statement to check for
‘a’, ‘e’, ‘i’, ‘o’, or ‘u’. If a vowel is not found, the program proceeds to the second-level IF...ELSE statement.
Of course, you can also place SWITCH statements in an IF...ELSE statement or vice versa although there are not
examples of nesting because nesting requires statements to contain statements of the same kind.
7.4.2 Block Statements

Although the SWITCH statement examples have used a single statement (plus the break statement) for each case item,
there is no theoretical limit to how many statements can be associated with each case. The IF...ELSE can also contain
multiple statements by combining them into what is called a block statement. A block statement groups multiple
statements by enclosing them in a pair or braces or curly brackets, ({}) . You have actually seen block statements
before, because all the statements between the curly brackets in the main() function actually make up one block
statement. If you attempt to create a block statement without using curly brackets the compiler will either generate
an error or assume that the first statement is associated with the IF or ELSE portion of the IF...ELSE statement and that
program is always to execute the additional statements.
The program below shows how an IF...ELSE statement can use block statements.

void main (void)
{
43

printf (“Enter another integer: ”);
if (number1 < number2)
{
printf (“%d is less than %d.\n”, number1, number2);
printf (“In other words, %d is greater than %d\n”, number2, number1);
}
else
if (number1 > number2)
{
printf (“%d is greater than %d.\n”, number1, number2);
printf (“In other words, %d is less than %d\n”, number2, number1);
}
else
{
printf (“You entered the same number both times.\n”);
printf (“How lazy can you get?\n”);
}
}
In this program, the block statements are used to place two printf() statements in the IF and ELSE portions of the
nested IF...ELSE statements. The block statements could also have used multiple statements to perform calculations or
anything else that the programmer wished the program to do for the condition associated with the block statement.
44
Section 8 - Loop Statements
8. Loop Statements
8.1 Overview
The sample programs in previous chapters have had one weakness that you may have noticed. The programs could
perform a specific task only once each time the program was run. Much of the power of computers is because
programs can repeat the same tasks over and over. For example, a word processor that allows only the user to type
only one key or even one sentence each time it runs isn’t much use. Executing the same statements more than once
is called looping. C provides three loop statements that allow programs to repeat a set of program statements: the
FOR statement, WHILE statement, and DO...WHILE statement. Each of these statements set up a specific type of loop
construct.
8.2 The FOR Statement

The FOR statement is used when the programmer knows how many times a loop must be repeated. The FOR
statement typically uses a variable, called a loop index, to keep track of how many times a loop has executed and
determine when to exit the loop. The FOR statement has the following form:
for (start condition; loop condition; index adjustment)

C statement;
The start condition specifier initializes the loop index, which should always be an integer to avoid issues with
floating point precision. The loop condition specifier is a Boolean expression that indicates the conditions for which
the loop should continue to execute. As long as loop condition is TRUE the program remain in the loop and executes
the C statement associated with the loop. The index adjustment specifier determines how the FOR statement will
automatically adjust the index variable at the end of each loop. Usually programs will increment the loop index by
one each time the loop executes, but programs can adjust the loop index in any other way the may be required. The C
statement that makes up the body of the loop can be a single statement or a block statement. The following program
shows a program that uses the FOR statement to calculate the factorial of a number.

void main (void)
{
int number, index;
unsigned long total = 1;

printf ("Enter an integer (0 to 12): ");
if ((number >= 0) &&
(number <= 12))
{
for (index = number; index > 0; index-‐-‐)
total *= index;
printf ("%d! = %lu\n", number, total);
}
else
printf ("Invalid entry ‘%d’.\n", number);
}
45
Note that the before executing the FOR loop the program uses an IF...ELSE statement discussed in the last chapter to
ensure that the entered value is between 0 and 12. This is because factorials are defined only for non-negative
numbers and 12! is the largest factorial that a long integer can represent. Assume that the number 8 is entered. When
the program is run the program will output the following:
Enter an integer (0 to 12): 8

8! = 40320
If the number 13 is entered, the program will output the following:
Enter an integer (0 to 12): 13

Invalid entry ‘13’.
8.3 The WHILE Statement

The WHILE statement is used when the programmer knows when a loop should execute, but does not know exactly
how many times it will execute. The WHILE statement has the following form:
while (Boolean expression)

C statement;
The WHILE statement evaluates the Boolean expression specifier and executes the C statement associated with the
WHILE statement if Boolean expression is TRUE. If the Boolean expression specifier is FALSE to begin with, the
WHILE loop will never execute. As with the FOR statement the C statement in a WHILE statement can be a single
statement or a block statement.
The following program demonstrates how a WHILE statement allows a user to run the factorial program from above
as many times as they wish. When the user wishes to end the program, all they need do is enter a negative number.

void main (void)
{
int number = 0, index;
unsigned long total;

while (number >= 0)
{
printf ("Enter an integer (0 to 12 or a negative value to exit): ");
if ((number >= 0) &&
(number <= 12))
{
total = 1;
for (index = number; index > 0; index-‐-‐)
total *= index;
}
else
46
Section 8 - Loop Statements
{
printf ("Invalid entry ‘%d’.\n", number);
}
}
printf (“Exiting program.\n”);
}
Assume now that the numbers entered, in order, are 5, 6, 15, and –3. When the program is run, the program will
output the following.
Enter an integer (0 to 12 or a negative value to exit): 5
5! = 120
6! = 720
Enter an integer (0 to 12 or a negative value to exit): –3
Exiting program.
8.4 The DO...WHILE Statement

The DO...WHILE statement is similar to the WHILE statement, except that the DO...WHILE statement evaluates the
Boolean condition associated with the loop after executing the loop statement rather than before, so that loop will
always execute at least once. The DO...WHILE statement has the following form:
do
C statement;
while (Boolean expression);
The program below shows one way to implement the factorial program using a DO...WHILE statement.

void main (void)
{
int number, index;
unsigned long total = 1;

printf ("Enter an integer (0 to 12): ");
total = 1;
if ((number > 0) &&
(number <= 12))
{
index = number;
do
total *= index-‐-‐;
47
while (index > 0);
}
else
if (number == 0)
printf ("0! = 1\n");
else
printf ("Invalid entry %d\n", number);
}

Notice that because the DO...WHILE loop always executes at least once special code must be added to handle the case
when the number entered is 0. Loops in C programs often require careful coding and checking to ensure that the
minimum or maximum allowable values, called the boundary conditions, will not cause problems when the program
executes.
48
Section 9 - Defined and Derived Data Types
9. Derived and Defined Data Types

9.1 Overview
Elementary data types, which you studied in Chapter 2, are part of the C language definition. Elementary data types
like int and float are useful for working with data in many applications. As the example programs have shown
elementary data types each hold a single piece of information, such as the ASCII value of a keypress or the result of
a calculation. Sometimes, however, it is easier to group several pieces of data together. For example, an electronics
instructor must keep track of grades for every student in the class. While a program could have a separate variable
for each student, it would be more convenient if a single variable could keep track of the grade for every student.
Derived and defined data types allow programmers to organize and work more easily with data in programs. This
chapter will examine and demonstrate the use of these data types.
9.2 Derived Data Types

A derived data type is a data type that is based upon, or derived from, elementary data types, just as a brick wall
consists of multiple individual but identical bricks and a house consists of multiple and varied building components
like bricks, boards, shingles, drywall, and other building materials. C has two derived data types: arrays (which
consists of multiple identical data units, like the brick wall) and structures (which consists of multiple varied data
units, like the house). In technical terms, arrays are accumulations and structures are aggregations.
9.2.1 Arrays
An array is a storage unit that consists of multiple identical data units. One way to think of an array is as a container
with multiple spaces for objects of the same size, like a CD storage cabinet. Each storage space in the array is called
an element. Arrays can consist of any type of elementary data type, but each element must be the same. An array
declaration has the form
elementary_data_type variable_name[number of elements]
The declaration for a 10-element array of int with the name int_array would be:
int int_array[10];
As you can see, the only difference between declaring an integer array and an integer variable is the addition of the
number of elements in brackets. Similarly, the declaration of an 80-element array of char named message would be:
char message[80];
Arrays can be initialized at the time they are declared by providing a list of the array data separated by commas in
curly brackets ({}). If this method is used to initialize an array, the list must initialize every element in the array. For
example, an array with five elements must have a list that contains values for all five elements. The following shows
how to declare and initialize five-element array of int values with the values 0 through 4:
int int_array[5] = {0, 1, 2, 3, 4};
The name of the array variable and the element number in brackets are used to access a specific element in the array.
One thing to remember, however, is that numbering of elements in an array begins with 0 and not 1. Therefore, the
nth element in an array has the element number n – 1. For example, a statement to store the number 23 in the fifth
element of int_array[] would be:
49
int_array[4] = 23;
Similarly, a statement to print message[0], which contains the first character in message[], would be:
printf (“The first character in message[] is %c\n”, message[0]);

The program below demonstrates how a 10-element integer array can be used as a look-up table of squares. The first
part of the program calculates and stores the values for 12 to 102 in the array, and the second part prints the square of
a number entered by the user.
#include <stdio.h> /* Required for scanf() and printf() functions. */

void main (void)
{
int squares[10], index;

// Load the look-‐up table.

printf (“Initializing table values...”);
for (index = 0; index < 10; index++)
{
squares[index] = (index + 1) * (index + 1);
}
printf (“done!\n”);

// Use the look-‐up table to print the square of a number.

while (index != 0) /* index is initially 10 from loading the table */
{
printf (“Enter a number between 1 and 10 (0 to exit): ”);
scanf (“%d”, &index);
if ((index > 0) &&
(index < 11))
printf (“The square of %d is %d.\n”, value, squares[value – 1]);
}
printf (“Exiting program.\n”);
}
The for loop, which loops for values of 0 through 10, initializes each element of the array. Note that because the
array elements begin with 0 while the values in the array begin with the square of 1, the program loads element
number n with the square of (n + 1). Once the table is loaded the program prompts the user for a number between 1
and 10, or 0 to exit the program. The program performs range checking to ensure the input is between 1 and 10 and
returns the square of numbers between 1 and 10, exits on 0, and ignores all other input values. Assume that a user
enters the values 20, 5, 3, –1, and 0 when the program is run. The program output will be:
Initializing table values...done!

Enter a number between 1 and 10 (0 to exit): 20
50
The square of 5 is 25.
The square of 3 is 9.
Enter a number between 1 and 10 (0 to exit): –1
Exiting program.
The range checking that the program performs on the input does more than simply ensure that the user enters valid
data for the stored values in the look-up table. It prevents the program from accessing memory outside the memory
locations defined for the array. If a program attempts to access memory other than that allocated for the program
data, the program could lock up (stop responding), crash (end unexpectedly), corrupt data used by other programs,
or lock up the computer.
While this example program may seem a trivial use for an array, programs often use look-up tables to speed up
execution. For example, rather than calculating the sine or cosine of an angle a program might preload tables once
with values of these functions in 0.1° increments and then simply access the values rather than spend the time
needed to recalculate them.
9.2.2 The struct Data Type

The struct (structure) data type is similar to the array data type, but the elements of a structure, called fields, can be
different elementary data types. The form of a struct data type is:
struct struct_name
{
elementary_data_type_1 field_name_1;
elementary_data_type_2 field_name_2;
...
elementary_data_type_n field_name_n;
}
Structure variables can be declared in one of two ways. The most obvious way is to first define the structure and
then declare the variable. The second way is to declare the variable at the time the structure is defined. The
following examples show two ways to declare a variable named impedance for a struct type called complex that
consists of a real float field and an imaginary float field. The first method to declare a structure is:
struct complex
{
float real;
float imaginary;
};
struct complex impedance;
The second way to declare a structure is:
struct complex
{
float real;
51
float imaginary;
} impedance;
The method used to declare a struct variable is a matter of personal preference, but in the interests of clarity it’s best
to be consistent when doing so.
Structures can be initialized at the time they are declared by initializing fields with a list of values in curly brackets
({}) similar to the way that arrays are initialized. The following illustrates how to initialize both the real and
imaginary fields of impedance with the values 1.0 and –2.0:
struct complex
{
float real;
float imaginary;
} impedance = {1.0, –2.0};
The first value in the list (1.0) initializes the first declared field (real) and the second value in the list (-‐2.0) initializes
the second declared field (imaginary). Note that the statement must initialize all fields of a structure.
Accessing data in a structure consists of specifying the structure and the field within it that contains the data. This
can be done in more than one way, but the most common form for specifying a structure field is:
struct_name.field_name
The second way of specifying fields, which uses pointers, will be discussed in a later chapter.
The program below illustrates how struct variables can be used to multiply complex numbers in rectangular form.
#include <stdio.h> /* Required for scanf() and printf() functions. */

void main (void)
{
struct complex
{
int real = 0;
int imag = 0;
};

struct complex number1, number2, product;

// Input the complex number to be multiplied

printf (“Enter the real and imaginary parts of Number 1: ”);
scanf (“%d %d”, &(number1.real), &(number1.imag));
printf (“Enter the real and imaginary parts of Number 2: ”);
scanf (“%d %d”, &(number2.real), &(number2.imag));

/*
Multiply the numbers. For imaginary numbers (R1 + jI1) and (R2 + jI2)
52
the product from the FOIL (first, outer, inner, last) expansion rule is:

(R1*R2 – I1*I2) + j ((R1 * I2) + (R2 * I1))

*/

product.real = number1.real * number2.real – number1.imag * number2.imag;
product.imag = number1.real * number2.imag + number2.real * number1.imag;
printf (“The product is %d + j(%d).\n”, product.real, product.imag);
}
Note that in this program each scanf() has the user input two values at time. The scanf() function can theoretically
input as many values at a time at once, but the user must enter the values so that the input matches the format of the
scanf() function. In this case the user must enter two integers separated by at least one space. Note also that the
address of the field is specified as &(structure_name.field_name). C will also allow &structure_name.field_name
without the parentheses, but in this case the parentheses were included for clarity.
Assume that the user enters the values 3 and –4 for the first complex number and 13 and 5 for the second complex
number. The program output will be:
Enter the real and imaginary parts of Number 1: 3 –4
Enter the real and imaginary parts of Number 2: 13 5
The product is 59 + j(–37).
In this example the fields of the structures were both int data types (so that arrays could have been used), but
structures typically have different data types for fields. For example, the declaration of a struct data type called
float_struct that holds the integer and fractional portion of a number in fields called whole and fract, respectively,
would be:
struct float_struct
{
int whole;
float fract;
};
9.3 Defined Data Types

A defined data type is one that the programmer creates and that are based on underlying elementary data types. Just
as with derived data types, defined data types exist to simplify working with specific types of data. One defined data
type is the enum (for enumeration) data type. Other defined data types are created using typedef (for type definition)
statements.
9.3.1 The enum Data Type

The enum data type is a special variation of the int data type. The enum data type associates a finite set of integer
values with special identifiers called enumeration constants. An example that illustrates the concept of the enum data
type are a list of numbered items on a menu. The numbers of the items corresponds to the integers underlying an
enumerated variable, whereas the item descriptions correspond to the enumeration constants. An enum declaration
has the following form:
enum enum_variable {enum_constant_1, enum_constant_2, ..., enum_constant_n};
53
The declaration of an enum data type called rainbow with the enumeration constants red, orange, yellow, green, blue,
indigo, and violet would be:
enum rainbow {red, orange, yellow, green, blue, indigo, violet};
As with structures, enumerated variables can be declared in one of two ways. The following examples show two
ways to declare a variable named part_list for an enum type called components that contains the enumeration
constants resistor, capacitor, inductor, diode, and transistor. The first method to declare the enum variable is:
enum components {resistor, capacitor, inductor, diode, transistor};

enum components part_list;

The second method to declare the enum variable is:
enum components part_list {resistor, capacitor, inductor, diode, transistor};
Once an enum variable is declared it can assume any of the enumeration constant values. By default C assigns the
enumeration constants consecutive integer values to represent their position in the list, beginning with 0 for the first
constant up through n – 1 for the nth constant. For the components data type the default position of resistor would be
0, capacitor would be 1, and transistor would be 4. The programmer can change these values by explicitly assigning
an integer value to one or more of the enumeration constants as shown below:
enum components part_list

{
resistor,
capacitor = 4,
inductor,
diode = 5,
transistor = 0
};
For the example above C will assign the specified position values to the enumeration constants resistor, diode, and
transistor respectively, and position values one higher than that of the preceding enumeration constant to the
unassigned constants capacitor and inductor. This gives the following values for the enumeration constants:
resistor = 0, capacitor = 4, inductor = 5, diode = 5, transistor = 0
Note that different enumeration constants in an enum data type can share the same position value, and that the
position value is not the same as enumeration constant’s position in the list declaration. To keep things simple, it’s
generally best to let C assign default values to the enumeration constants unless there is a very compelling reason to
assign different values.
Because the enum data type is based on the int data type, the enum data type has operators similar to int arithmetic,
logic, and relational operators. These operators are:
= Assignment Operator
54
This operator is similar to the integer assignment operator and stores a specific enumeration
constant in an enum variable. An enum variable can be assigned only enumeration constants
defined for the specific enumeration data type of that enum variable.
== Equals Operator
The equals operator compares two enum operands and determines whether or not they have the
same position value. If the two operands have the same value the result is TRUE, and if not the
result is FALSE.
!= Not Equals Operator
The not equals operator compares two enum operands and determines whether or not they have
different position values. If the two operands have different values the result is TRUE, and if not
the result is FALSE.
<<= Lower Relational Operator
The lower relational operator compares two enum operands and determines whether or not the
position of the operand to the left of the operator is lower in the enumeration constant list than that
of the operand to the right of the operator. If the left operand has a lower position value than the
right operand the result is TRUE, and if not the result if FALSE.
>>= Higher Relational Operator
The higher relational operator compares two enum operands and determines whether or not the
position of the operand to the left of the operator is higher in the enumeration constant list than
that of the operand to the right of the operator. If the left operand has a higher position value than
the right operand the result is TRUE, and if not the result if FALSE.
Enumeration variables are very useful in switch statements. The following program demonstrates how programs can
use enum variables. One enum variable represents the days of the week. The other implements a Boolean data type.
Both make the program much easier to understand and analyze than a program using integer values.
#include <stdio.h> /* Required for printf() functions. */

void main (void)
{
enum days
{
Monday = 0,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
};

enum days today = Monday;

enum Boolean
{
FALSE = 0,
TRUE
};

55
enum Boolean quit = FALSE;

while (quit != TRUE)
{
switch (today)
{
case Sunday : printf (“But the child that’s born on the Sabbath day\n”);
printf (“Is bonnie and blithe and good and gay.\n”);
quit = TRUE;
break;
case Friday : printf (“Friday’s child is loving and giving,\n”);
today = Saturday;
break;
case Tuesday : printf (“Tuesday’s child is full of grace,\n”);
today = Wednesday;
break;
case Thursday : printf (“Thursday’s child has far to go,\n”);
today = Friday;
break;
case Saturday : printf (“Saturday’s child works hard for a living,\n”);
today = Sunday;
break;
case Wednesday : printf (“Wednesday’s child is full of woe,\n”);
today = Thursday;
break;
case Monday : printf (“Monday’s child is fair of face,\n”);
today = Tuesday;
break;
}
}
printf (“\nEnd of program.\n”);
}
When run, this program will enter and remain in a while loop until the value of the enum variable quit becomes
TRUE. Each time the loop executes, the switch statement will print out a line based upon the value of the enum
variable today. For the first iteration, the value of today is Monday, so the program executes the code associated with
the case statement for Monday. This prints “Monday’s child is fair of face,” and changes the value of today to Tuesday.
The variable quit is still FALSE so the while loop repeats with today equal to Tuesday. This process continues until
the case statement for Sunday sets quit to TRUE, and the program exits the while loop. The program then prints “End
of program.” and ends. The program output will be:
Monday’s child is fair of face,

Tuesday’s child is full of grace,
Wednesday child of full of woe,
Thursday’s child has far to go,
Friday’s child is loving and giving,
Saturday’s child works hard for a living,
56
But the child that’s born on the Sabbath day
Is bonnie and blithe and good and gay.

End of program.
The program above may seem somewhat convoluted and trivial, but it embodies the basic structure of a software
state machine that embedded C programs often use and that occurs in software digital design tools like VHDL. Each
case statement specifies the actions that should take place in a specific state, and specifies the state to which the
machine should transition next. The following shows the C state machine for a Gray code sequence:

void main (void)
{
enum GrayCode
{
G0,
G1,
G2,
G3
};

enum GrayCode state = G0;

enum Boolean
{
FALSE = 0,
TRUE
};

enum Boolean quit = FALSE;

printf (“Entering machine\n”);
{
printf (“Exeecuting state machine\n”);
switch (state)
{
case G0 : printf (“In machine state 0.\n”);
state = G1;
break;
state = G3;
break;
quit = TRUE;
break;
57
state = G2;
break;
}
}
printf (“\nEnd of program.\n”);
}
When this program is run its output will be:
Entering state machine.

Executing state machine.
In machine state 0.
In machine state 1.
In machine state 3.
In machine state 2.

End of program.
In this example the program does very little, but each case statement can contain statements to perform whatever
tasks the program should perform in that state.
9.3.2 User-Defined Types

The enum data type allows programmers to define a set of values that variables can use and that helps make
programs easier to understand. For example, the enum Boolean allowed the program to use the enumeration
constants FALSE and TRUE to implement Boolean variables, rather than the integer values 0 or 1. This makes the
relational expression
that tests the value of the variable and its intent easier to understand than the integer expression
while (quit != 1)
C provides another way for programmers to define program data types. This is the typedef expression which allows
programmer to assign a name to data types and use that name when declaring variables of that type. A typedef
statement has the form:
typedef data_type data_type_name;
A typedef statement to set up a Boolean data type using an enum data type with enumeration constants FALSE and
TRUE would be:
typedef enum
58
{FALSE = 0,
TRUE} Boolean;
Similarly, a typedef statement to set up a polar data type using a struct data type with the fields magnitude and angle
would be:
typedef struct
{
float magnitude;
float angle;
} polar;
Once defined, the program can use the defined data type to declare variables in exactly the same way as for standard
C elementary and derived data types. For example, the C declaration for a Boolean variable named valid would be:
Boolean valid;
Similarly, the C declaration for a polar variable named admittance would be:
polar admittance;
At first defining a data type and declaring variables for that type doesn’t seem much different or any more useful
than using standard C data types. However, using typedef statements offers some significant advantages.
A basic advantage of typedef is that it helps make C code more readable. C allows programs to be very cryptic, so
programmer should attempt to make source code as readable as possible.
Another advantage of typedef is that simplify names of data types can help prevent coding errors. For example,
using long data type names like unsigned long int in a program is prone to typing errors and can become tedious.
However, the statement
typedef unsigned long int uint32;
allows a programmer to use uint32 to declare unsigned long int variables more simply and with less chance of errors.
Another advantage of typedef is that a defined type allows programmers to make corrections throughout the program
by changing a defined data type in one place in the program. Suppose, for example, that a program contained the
following typedef statement:
typedef my_int unsigned int;
After declaring numerous my_int variables throughout a program, the programmer discovered that the my_int
variables must be signed long int data types rather than unsigned int. Without the my_int defined data type every
instance of unsigned int in the program must be located and individually changed to signed long int. With the defined
my_int data type only the unsigned int in the typedef statement need be changed.
59
Section 10 - Strings
10. Strings
10.1 Overview
Strings in C are sequences of characters. One difficulty in discussing strings is that the C language originally did not
define a string data type. Instead, it allowed C programs to work with character arrays. Unfortunately character
arrays and strings are not quite the same because the arrays fundamentally treat elements as independent values and
strings consist of characters that are treated as a whole. Fortunately many C compilers provide support for strings
because strings are used so often in programs. Although you may not have realized it, the printf() function has been
using strings. In the “Hello, world” program “Hello, world\n” is a string. This chapter will examine the strings and
how to work with them in more detail.
10.2 Strings as Character Arrays

From the discussion of arrays in the previous chapter programs can initialize arrays by specifying the value of each
element. For example, the program can initialize a character array called hello[12] with the string “Hello, world” with
the statement:
char hello[12] = {'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd'};
This method has two drawbacks. The first is that initializing a character array with a string is extremely tedious. The
second is that it treats a string as collection of individual characters rather than an actual data type. However, just as
C considers any character between single quotes to be a char value, it considers any sequence of characters between
double quotes to be a string. Although C does not have a specific string data type, it does allow programs to
initialize character arrays with strings. The program below illustrates how this is done.
#include <stdio.h> /* Required for printf() function. */

void main (void)
{
char hello[13] = "Hello, world";

// Print the string

printf ("%s\n", hello);
}

When this program it run it will output the following:
Hello, world
You should note two things about this program. The first is that although “Hello, world” consists of only 12
characters, the character array to hold it has 13 elements. This is because a string is NOT just a sequence of
characters. When designation a sequence of characters as a string C uses a special format called ASCIIZ that adds a
zero, or NULL, after the last character in the string. The following program illustrates this.

void main (void)
{
61
char buffer[80] = "Hello, world",
value;
int index;

// Print the string

{
value = buffer[index];
if (value != 0)
printf ("buffer[%2d] = \t %3d = \t '%c'\n", index, value, value);
else
{
printf ("buffer[%2d] = \t %3d = \t NULL\n", index, value);

// If end of string reached, terminate the loop by setting the index to 80.
index = 80;
}
}
}

This program loops through the 80-element character array containing “Hello, world” until it reaches the last element
in the array or the value 0, whichever occurs first. If it reaches the value 0 before the last element in the array it
terminates the loop by setting the loop index to 80. For each loop the program uses the printf() function to specify
the buffer element and the element value, both as an integer and as an ASCII character, using the tab character \t to
format the values in columns. If the value in the element in 0, which is not printable, it prints NULL. When the
program is run it outputs the following:
buffer[ 0] = 72 = 'H'

buffer[ 1] = 101 = 'e'
buffer[ 2] = 108 = 'l'
buffer[ 3] = 108 = 'l'
buffer[ 4] = 111 = 'o'
buffer[ 5] = 44 = ','
buffer[ 6] = 32 = ' '
buffer[ 7] = 119 = 'w'
buffer[ 8] = 111 = 'o'
buffer[ 9] = 114 = 'r'
buffer[10] = 108 = 'l'
buffer[11] = 100 = 'd'
buffer[12] = 0 = NULL
As the program shows, C has added a 0 to the string “Hello, world”.

The second thing to note is that the printf() function uses the %s to specify a string variable type. The printf()
function requires a null-terminated ASCIIZ string to properly print the string. Otherwise, it will continue to print
characters in memory that follow the variable until it encounters a 0 (which may take some time).
62
10.3 Working with Strings
The scanf() and printf() functions specified in stdio.h can input and output strings. The previous section
demonstrated how to use the printf() function to print strings. Programs often use scanf() and printf() together so that
they can interact with the user. The program below is a simple example of how programs do so.
#include <stdio.h> /* Required for printf() and scanf() functions. */

void main (void)
{
char first[80],
last[80];

printf ("Hello! What is your first name? ");
scanf ("%s", first);
printf ("Hello, %s. Nice to meet you. What is your last name? ", first);
scanf ("%s", last);
printf ("I hope that the %s family is well, %s.", last, first);
}

Assume that the user enters “John” and “Doe” when prompted for a first and last name. When the program is run it
will output the following:
Hello! What is your first name? John

Hello, John. Nice to meet you. What is your last name? Doe
I hope that the Doe family is well, John.
Something you might have noticed is that the scanf() function, which requires the address of the variable to store
entered information, does not use the & symbol with the name of the character arrays. This is because C does not
treat array names (including names of character arrays used to store strings) as it does other variable names. When a
program uses the name of a variable it means the value contained in the variable, so that programs must use the &
symbol with the variable name to specify the address of the value. However, arrays contain multiple values so that
the name of the array cannot (and therefore does not) refer to the “value” of the array. Instead, C uses the name of an
array to refer to the starting address of an array, which is also the address of the first element of the array. For the
character array first[80] and last[80], for example, C considers first and &first[0] as well as last and &last[0] to be the
same. The following program demonstrates this.

void main (void)
{
char first[80],
last[80];

printf ("Hello! What is your first name? ");
scanf ("%s", &first[0]);
printf ("Hello, %s. Nice to meet you. What is your last name? ", first);
scanf ("%s", last);
printf ("I hope that the %s family is well, %s.", &last[0], &first[0]);
63
}
When this program is run, it will output the following:
Hello! What is your first name? John

Hello, John. Nice to meet you. What is your last name? Doe
I hope that the Doe family is well, John.
C treats strings in the same way as it treats arrays. C refers to a string, such as “This is a string.”, using the starting
address of memory that contains the sequence of characters.
10.3.1 String Functions in C

Because C uses addresses to refer to strings and arrays, programs cannot work with these types of variables as it
does with other data types. Consider the following program:

void main (void)
{
char buffer[80] = "This is a string.";

if (buffer == "This is a string.")
printf ("The strings match.\n");
else
printf ("The strings do not match.\n");
}
When the program is run, it will output the following:
The strings do not match.
There is no trick to this. Although the contents of buffer match the string, the program evaluates the Boolean
expression
buffer == “This is a string.”
to determine whether or not the address of buffer is the same as the address of “This is a string.” and prints “The
strings do not match.” because the addresses are not the same. Similarly, suppose a program cannot use the “=”
assignment operator to copy the contents of one character array into another because one address cannot be copied
into another address. One approach to accomplish these operations is to write your own code to do so. For example,
the following program copies the contents of string1 into string2:

void main (void)
{
64
char string1[80] = “This is a string.”,
string2[80] = “This string is different”;
int index = 0;

printf ("Original:\n");
printf ("String 1 = '%s' and String 2 = '%s'\n", string1, string2);
printf ("\nNow copying String 1 to String 2\n\n");

/*
Use a loop to copy the characters from string1 to string2, incrementing the index
with each loop. End the loop when either the last valid element is copied or the
or the null terminator is reached.
*/

while ((index < 79) && (string1[index] != 0))
string2[index] = string1[index++];
string2[index] = 0;
printf ("New:\n");
}
When the program is run, it will output the following:
Original:
String 1 = ‘This is a string’ and String 2 = ‘This string is different’

Now copying String 1 to String 2

New:
String 1 = ‘This is a string’ and String 2 = ‘This is a string’
Similarly, the following program determines whether two strings are identical.

void main (void)
{
char string1[80] = "This is a string.",
string2[80] = "This string is different.",
string3[80] = "This is a string.";
int index,
same;

/*
Use a loop to compare the characters of string1 and string2, incrementing the index
with each loop. End the loop when two characters are not the same, the last valid
element is reached, or the null terminator of either string is reached.
65
*/

index = 0;
same = 1;
while ((same == 1) && (index < 79) &&
(string1[index] != 0) && (string2[index] != 0))
if (string1[index] != string2[index++])
same = 0;
if (same == 1)
printf ("'%s' is the same as '%s'\n", string1, string2);
else
printf ("'%s' is not the same as '%s'\n", string1, string2);

index = 0;
same = 1;
while ((same == 1) && (index < 79) &&
(string1[index] != 0) && (string3[index] != 0))
if (string1[index] != string3[index++])
same = 0;
if (same == 1)
else
printf ("'%s' is not the same as '%s'\n", string1, string3);
}
While writing your own code to handle strings is adequate, C has library functions for working with strings. One of
these is the strcpy() function that does the same thing as the while loop in the above program. The following
program rewrites the program to use the strcpy() function:

#include <string.h> /* Required for the strcpy() function. */

void main (void)
{
string2[80] = "This string is different";

printf ("Original:\n");
printf ("\nNow copying String 1 to String 2\n\n");

/*
Use the strcpy() function to copy string1 to string2.
*/

strcpy (string2, string1);
66
printf ("New:\n");
}
Note that the program must include the string.h reference so that the compiler can access the strcpy() function. Note
also that the strcpy() function specifies the destination as the first parameter, and the source as the second parameter.
When this program is run it will output the same information as before:
Original:
String 1 = ‘This is a string’ and String 2 = ‘This string is different’

Now copying String 1 to String 2

New:
String 1 = ‘This is a string’ and String 2 = ‘This is a string’
Another string function that string.h allows programs to access is the strcmp() function. This function compares the
corresponding characters in two strings and uses and integer value to indicate whether or not the strings are
identical. If the strings are identical, the strcmp() function returns a value of 0. If the strings are not identical the
function returns a value of 1 or –1. A 1 indicates that the value of the first differing character in the first parameter is
greater than that of the corresponding character in the second parameter. A –1 indicates that the value of the first
differing character in the first parameter is less than that of the corresponding character in the second parameter.
Programs typically use strcmp() only to determine whether two strings are identical or not, although knowing the
relative value of two strings can simplify programs that must sort lists and other text values. The following program
demonstrates the basic use of strcmp() to determine whether or not two strings are identical:

#include <string.h> /* Required for strcpy() function. */

void main (void)
{
string2[80] = "This string is different.",
string3[80] = "This is a string.";
int result;

printf ("Comparing '%s' with '%s'\n", string1, string2);
result = strcmp(string1, string2);
if (result == 0)
else
printf ("'%s' is not the same as '%s'\n\n", string1, string2);
printf ("\nComparing '%s' with '%s'\n", string1, string3);
result = strcmp(string1, string3);
if (result == 0)
else
printf ("'%s' is not the same as '%s'\n\n", string1, string3);
67
}
Note that the program stores the value returned by strcmp() in an integer variable. The if statement could have used
strcmp(string1, string2) directly but programs often store the return value of a function in case the value must be
accessed more than once and this takes less time than evaluating the function each time.
When the program is run it will output the following:

Comparing 'This is a string.' with 'This string is different.'
'This is a string.' is not the same as 'This string is different.'

Comparing 'This is a string.' with 'This is a string.'
'This is a string.' is the same as 'This is a string.'
68
Section 11 - Pointers
11. Pointers
11.1 Overview
A pointer contains a memory address that programs can use to access or store information at that memory address.
Because C does not restrict these addresses pointer can theoretically read from or write to any location in memory
(including the internal registers of processors that memory map their register set). This ability also makes pointers
very dangerous because accessing restricted memory locations can cause the program or computer system to crash.
This chapter examines the basics of how pointers are declared, initialized, and used in programs.
11.2 The Nature of Pointers

Data types like int and struct contain data with which programs work. Whenever a program declares a variable it
allocates, or sets aside, memory to hold data. For example, the variable declaration
int int_val1, int_val2;
allocates two regions of memory of two bytes each. The program then associates the names int_val1 and int_val2
with the addresses of that allocated memory. When the program stores data in a variable the processor writes that
data to that variables’ memory address, and when the program obtains data from int_val the processor reads the data
at int_val’s address. The compiler and operating system work together so that once a program declares a variable
that variable name will always reference the same address, and other declared variables do not refer to the same
address. For the example above the compiler will not give int_val1 and int_val2 the same address.
A pointer is a data type that contains the address of a data type (including other pointers). In C pointers are four-byte
integer values, similar to the long int data type. Programs typically work with the data at the address contained in the
pointer, although sometimes programs do work with the contents of the pointer. Because changing the contents of a
pointer changes the memory location that the pointer references, programs can use the same pointer to access
different memory locations simply by changing the contents of the pointer. For example, incrementing or
decrementing a pointer allows programs to access consecutive data locations in memory, like incrementing or
decrementing the index of an array.
11.3 Declaring Pointers

Declaring a pointer in C is similar to declaring the data type referenced by the pointer. The difference is that the
pointer is prefixed by an asterisk (*). The example below shows the variable declarations for a double and pointer to
double.
double double_val; /* double_val is a double data type */

double *double_ptr; /* double_ptr is a pointer to double data type */
Note that these two variables could also have been declared as follows:
double double_val, *double_ptr;
Declaring a pointer is not the same as initializing a pointer, just as declaring a double variable is not the same as
assigning a double value to it. Compilers typically will generate a warning if a program attempts to use a variable
before initializing that variable. The big difference is that the consequences of using an uninitialized pointer can be
far more drastic than for other uninitialized data types, because the value of an uninitialized pointer can potentially
reference (and consequently change the data in) any location in the computer system.
69
11.4 Initializing Pointers
There are several ways to initialize pointers in C. Which method is used depends upon the purpose of the pointer and
available memory information.
11.4.1 Direct Address Assignment

The first method for initializing a pointer is simply to load the pointer variable with a four-byte memory address, as
shown in the statements below:
float *float_ptr; /* Declare the pointer to float variable */

float_ptr = 0x10L; /* Initialize int_ptr with the address 0x00000010 */
As the comments indicate, the first statement declares the pointer to float variable float_ptr. The second statement
then initializes the pointer to the hexadecimal 32-bit value (indicated by the hexadecimal prefix 0x and the long
suffix “L”) 0x00000010. While this is the simplest way it potentially is also the most dangerous because there is no
guarantee that it is safe to use the assigned memory address. Programmers use this method only when they have a
system memory map that ensures they safely can use specific memory regions.
An important note here is that the “L” suffix must be used when the value itself cannot guarantee that it is a 32-bit
value. For the example above the hexadecimal value 0x10, or decimal value 16, can be stored in one, two , or four
bytes. Using 0x00000010 will not help, as the compiler will see no difference between 0x10 or 0x00000010 because
they both represent the decimal value 16. To be safe, always add the “L” suffix when specifying a 32-bit value.
11.4.2 Assigning a Variable Address

The second method for initializing a pointer is to assign the address of a declared variable to it. The statements
below shows how this can be done.
int int_val, *int_ptr; /* Declare the int and pointer to int variables */
int_ptr = &int_val; /* Initialize int_ptr with the address of int_val */
As the comments indicate the first statement declares the int variable int_val and the pointer to int variable int_ptr.
The second statement then copies the address of int_val (indicated by the address prefix “&”) into int_ptr. This
method is safe, but you might wonder why you would need a pointer to variable when you can access the variable
directly. The next chapter will answer this question more fully in the next section, but consider the following
program:
#include <stdio.h> /* Required for the printf() function */

void main (void)
{
int int_array[10],
index,
*int_ptr;

// Load the array with the square of the element number.

{
int_array[index] = index * index;
}
70

// Use a pointer to print out the contents of the array.

int_ptr = int_array; /* Recall that the name of an array is an address. */
while (int_ptr <= &(int_array[9]))
{
printf (“%d\n”, *int_ptr++);
}
}

The first part of the program is fairly straightforward. The for loop initializes each element of the array with the
square of the array index (i.e., int_array[0] = 02, int_array[1] = 12, ... int_array[9] = 92). The second part is a little more
cryptic, but actually not very difficult to understand. The pointer is initialized with the address of the array, which is
the same as &(int_array[0]), or the address of the first array element. Each iteration of the while loop then prints out
the contents of the array by accessing the int value that is indicated by the pointer and then post-incrementing the
pointer to access the next array element. The program will continue to loop until the pointer exceeds &(int_array[9]),
the address of the last element in the array. When this program is run, it will output the following:
1
4
9
16
25
36
49
64
81
End of program.
This may not seem like a very useful technique, because the program could have used a for loop similar to the one
that initialized the array to print the contents. There are some subtle advantages to using a pointer, however, One is
that the array required an extra variable called index to loop through the elements, whereas the pointer did not.
Another is that initializing a pointer once and then incrementing it usually is somewhat faster than using an index as
the offset from the starting address of an array to calculate an address each time the program must access the next
element.
Using a pointer with an array type is especially useful when working with strings. The following program
demonstrates how a pointer can be used with strings.

void main (void)
{
char buffer[80] = “This is a string.”,
*char_ptr;

char_ptr = buffer; /* Set pointer to start of string. */
printf (“Original string = %s\n”, buffer);
while (*char_ptr++ != 0)
71
{
if ((*char_ptr >= ‘a’) &&
(*char_ptr <= ‘z’))
*char_ptr = *char_ptr + (‘A’ – ‘a’);
}
printf (“New string = %s\n”, buffer);
}
The program begins by declaring a char array initialized with the string “This is a string.”, declaring a pointer to char
called char_ptr, and initializing the pointer to the starting address of the array. After printing the original string, the
program executes a while loop that uses the pointer to check each character in the string to determine whether the
character is between ‘a’ and ‘z’ (i.e., it identifies the lower case characters in the string). If the character is lower
case, it adjusts the character value in the string by the ASCII offset between “A” and “a”, effectively changing any
lower case character to an upper case character. When the pointer reaches the end of the string (indicated by a value
of 0) the program exits the loop and prints the new string. The output of the program is as follows:
Original string = This is a string.

New string = THIS IS A STRING.
Again, the program could have processed buffer as an array but this probably would not have been as efficient.
Programs often process strings, so programmers try to make programs that scan and modify them as efficient as
possible.
11.4.3 Allocating Memory

The third method of initializing pointers uses memory allocation, in which the program requests the operating
system to allocate a specific amount of memory for the program to use. The program and operating system
automatically allocate memory each time the program declares a variable, but C allows programs to allocate
memory if the program requires it. The function typically used to do so is the malloc() (for “memory allocation”)
function. The form of using the malloc() function is as follows:
mem_ptr = malloc (number_of_bytes);
As the statement indicates, the program passes the function the number of bytes of memory it requires, and the
function returns a pointer value to the start of the allocated memory. If the operating system cannot allocate the
requested amount of memory it returns a NULL (or 0) value. Programs must always check the returned pointer value
to ensure that it is not NULL before attempting to use the pointer. The following program demonstrates the use of
malloc() for setting up an 80-byte character buffer.

#include <stdlib.h> /* Required for malloc() function. */

void main (void)
{
char *buffer; /* Declare pointer to character buffer. */

buffer = malloc (80); /* Request 80 bytes of memory for buffer. */
if (buffer != NULL)
{
72
printf (“What is your name? ”);
scanf (“%s”, buffer);
printf (“Hello, %s!\n”, buffer);
}
else
{
printf (“Unable to allocate memory.\n”);
}
}
This program is very similar to the early input and output programs that earlier chapters covered. However, rather
than using a pre-defined character array to store the input string this program uses malloc() to allocate 80 bytes of
memory and initializes the buffer pointer to char to the starting address of the allocated memory. If the starting
address returned by malloc() is not NULL, indicating that the operating system could allocate the requested memory,
the program proceeds to request the user’s name, store the response in allocated memory, and output the stored
string as part of a printf() message. If the starting address returned by malloc() is NULL, indicating that the operating
system could not allocate the requested memory, the program outputs a message to that effect and terminates.
Assume that the user’s name is Aubrey. If the program is able to obtain the requested memory when it is run, the
output will be as follows:
What is your name? Aubrey

Hello, Aubrey!
End of program.
If the program was unable to obtain the requested memory when it is run, the output will be as follows:
Unable to allocate memory.

End of program.
For this example the malloc() program was used to allocate 80 bytes of memory. This is because the program was
written to set up the same amount of space as that for an 80-character array and each character requires one byte of
memory. This is an easy to calculate, but suppose a program required memory for a complicated structure consisting
of char, int, double, other struct, and array types? Calculating the required number of bytes could be quite difficult
and allocating the wrong amount of memory could cause serious problems. To solve this problem C provides a
special function called sizeof() that returns the number of bytes in a specified data type. The form of the sizeof()
function is:
num_bytes = sizeof (data_type);
The sizeof() function can be used in conjunction with the malloc() function to ensure that the program attempts to
allocate the correct number of bytes. The following statement shows how this is done:
type_ptr = malloc (sizeof (data_type));
The following program shows the program above modified to use the sizeof() function to allocate memory for 80
char values:

73
#include <stdlib.h> /* Required for sizeof() and malloc() functions. */

void main (void)
{
char *buffer; /* Declare pointer to character buffer. */

buffer = malloc (80 * sizeof (char)); /* Request memory for 80 char values. */
if (buffer != NULL)
{
printf (“What is your name? ”);
scanf (“%s”, buffer);
printf (“Hello, %s!\n”, buffer);
}
else
{
printf (“Unable to allocate memory.\n”);
}
}
Here the parameter for the malloc() function is given as 80 * sizeof (char), which allocates memory for 80 char
values. This method can be used to allocate memory for any number of locations for any type of data.
11.4.4 Looking Ahead

Pointers are useful for some types of data processing, but their real strength lies in allowing sections of a program to
efficiently access data from other sections of the program. These sections are called functions, which allows
programs to increase cohesion (keep related code and data together) and reduce coupling (the effect of changes in
one section of a program on another). The next chapter will examine functions in C programming.
74
Section 12 - Functions in C
12. Functions in C
12.1 Overview
Except for very simple programs or programming examples like those in this tutorial very few C programs are
written as a single piece of code. Most programs consist of multiple code sections, each of which accomplish some
specific task. These code sections in C are called functions. The main() portion of every C program is a function,
which differs from other functions only in that it is the entry point into the program. Other chapters have discussed
standard C functions like printf() and strcpy() that perform common program tasks. This chapter examines how to
write and use functions in C programs.
12.2 Why Use Functions?

Before writing a function, programmers should understand why programs use functions so that they can write
functions effectively. Functions in C serve three major purposes.
1) Functions help to design, organize, and programs. This allows programmers to write, analyze, modify,
and maintain programs more easily. A difficulty that programmers often face is understanding just how to
write a program that must perform some very complex task. Functions allow programmers to break down
complex programs into smaller and more manageable tasks that are easier to understand, implement, and
modify.
2) Functions allow programmers to write, test, and integrate sections of code independently. This is
particularly useful for programmers working on large programming projects and for programs that require
more than one programmer. A programmer working independently can use functions to write and debug a
large program in stages, whereas a project manager can assign sections of a large project to members of his
team so that they can work in parallel and shorten the time needed to deliver the program.
3) Functions support modular code and simplify re-use of existing code. Programs often must perform the
same task or repeat the same many times, such as getting input from the user, performing some calculation,
or writing data to a file. Functions allow programmers to do this either by accessing a function in a pre-
existing library (such as printf()) or by writing the code for some task once and simply calling the function
each time the program requires it.
Functions are a powerful feature of C when used properly, but actually can be counter-productive when used
improperly. For example, a function that performs complex addition in a program that calculates circuit impedance
is a good application for a function, because the program likely must perform complex addition many times and
other mathematical programs would likely re-use a complex addition function. Writing a function that prints the
string “Hi” probably is not a good application for a function, because this function would have limited use and not
justify the effort of writing it. Understanding the purposes for which functions are intended will help to decide when
to use functions in programs.
12.3 Declaring Functions

12.3.1 Form of Functions
All functions in C have the following form:
return_type function_name (parameter list)

{
local variables;

function body;
return return_value;
}
75
The return_type indicates the data type that the function returns, such as int, float, or struct. If the function does not
return a value, the return type is void.
The function_name identifies the function and is used to call the function. Function names must be unique. In other
words, C programs cannot have two functions with the same name or have a function with the same name as a
function specified by an included header file. There are restrictions on function names just as with variables. In
general, function names that begin with an upper- or lower-case letter and contain only upper- or lower-case letters,
numbers, or underscores (_)are valid.
The parameter list identifies the data types and names of data, or parameters, that will be passed to the function. If
the function has no parameters then the parentheses can be empty or contain the word void. Parameters in the list are
separated by commas. These parameters are used in the function body.
The local variables identify the data types and names of variables that are used in the function in addition to the
parameters in the parameter list. Only the function has access to these variables unless they are passed to another
function.
The function body consists of standard C statements just like those used in main(). Statements can be calls to other
functions (or even to the same function although this technique, called recursion, is beyond the scope of this
tutorial).
The return return_value statement is the last statement executed by the function, although for functions returning
void this statement is omitted. The return_value must be the same type as the return_type. Typically return_value is
one of the local variables, although return can also specify a literal, such as
return 5;
for an int return value or
return ‘c’;
for a char return value. Functions can even return values by specifying an expression such as
return num1 + num2;
The function will evaluate the expression and return that value to the calling statement.
12.3.2 Some Examples of Functions

The following program illustrates a function that programs might use to report the severity of an error that occurs
during program operation.
void error_msg (enum error_type error)

{
printf ("There is ");
switch (error)
{
case NO_ERR : printf ("no error.\n");
break;
case MINOR_ERR : printf ("a minor error.\n");
break;
case MODERATE_ERR : printf ("a moderate error.\n");
break;
76
case SEVERE_ERR : printf ("a severe error.\n");
break;
}
}
The above function assumes that the program using the function has defined error_type as an enum type using a
statement similar to the following:
typedef enum error_type {NO_ERR = 0, MINOR_ERR, MODERATE_ERR, SEVERE_ERR);
The operation of the function is straightforward. Depending upon the value of the error_type variable error passed to
the function, it would print the type of error indicated by error. If the value of error is MINOR_ERR, the function
output will be as follows:
There is a minor error.
Programs often use a function of this sort to convert an enumerated type into a form that the user can understand.
Earlier demonstration programs could not directly output the values of enumerated Boolean type variables because
the 0 and 1 integer values the Boolean variables actually contained would be meaningless to most users. The
programs could have used an if or switch statement to output TRUE or FALSE as required, but this would have been
awkward. The following function would have been much more convenient:
void Boolean_msg (enum Boolean bool_val)

{
switch (bool_val)
{
case FALSE : printf ("FALSE\n");
break;
case TRUE : printf ("TRUE");
break;
}
}
Neither of the above functions returned a value. The following is an example of a function that returns a value to the
statement calling it.
float cube (float base)

{
float result = 0;

result = base * base * base;
return result;
}
For this example the calling statement passes the float value base to cube(). The function then calculates the cube of
base by multiplying base by itself three times, assigns the cubed value to result, and returns the value of result to the
calling statement. Note that this function could also be written as:
77
{
return base * base * base;
}
In this example the function will evaluate the expression base * base * base and return that value directly to the
calling statement.
A final example that uses multiple parameters is the program below, which calculates the hypotenuse of a right
triangle using the Pythagorean theorem. Because this function uses the C sqrt() function, the program containing the
function must include a reference the math.h which contains information about the sqrt() function.
float Pythagoras (float x_side, float y_side)

{
float hypotenuse = 0;

hypotenuse = sqrt (x_side * x_side + y_side * y_side);
return hypotenuse;
}
12.3.3 Function Prototypes

As previous program chapters have shown, the C compiler must know what values are passed to and returned from a
function so that it can generate the correct program code. This information is provided using a function prototype.
The function prototype of C functions are provided in header files such that are specified at the start of the program
(e.g., the prototype for scanf() is contained in the header file stdio.h). For program functions programs can contain
prototype statements at the start of the program. The exact location of the prototype statement is not important
provided the statement appears before any statement that attempts to call the function, but placing them at the start
of the program makes analyzing the program much easier.
Prototype statements have the form:
return_type function_name (parameter data types);
The return_type specifies the data type that the function will return.
The function_name identifies the name of the function associated with the function prototype.
The parameter data types comprise a list of the data types for all the parameters that will be passed to the function.
Data types in the list are separated by commas. The order of the data types must match the order of data types in the
function’s parameter list.
For the function examples shown in Section 12.3.2 the prototypes would be:
void error_msg (enum error_type);

void Boolean_msg (enum Boolean);

float cube (float);

float Pythagoras (float, float);
78
12.4 Calling Functions
Programs call function by including a statement that specifies the function, the values passed to the function, and
(optionally) a variable into which to copy the return value. The form of a function call is:
return_variable = function_name (values list);
The return_variable is the variable into which the statement copies the return value of function_name. Because C can
use the return value directly this variable is not required, although it makes the code easier to understand and allows
other statements to use the return value. The following example use the Pythagoras() to demonstrate this:
side3 = Pythagoras (side1, side2)

if (side3 > 5.0)
{
printf (“Hypotenuse %f is greater than 5.0\n”, side3);
}
is functionally identical to
if (Pythagoras (side1, side2) > 5.0)

{
printf (“Hypotenuse %f is greater than 5.0\n”, side3);
}
The return_variable is always omitted if the return value of function_name is void.

The function_name specifies the name of the function to execute.
The values list provides the parameters for the statement to pass to the function being called. The sequence and data
types of the values list must match those of the parameter list of the function being called.
The following examples demonstrate programs that call the function examples in Section 12.3.2. The first program
below exercises the error_msg() function.

typedef enum error_type {NO_ERR = 0, MINOR_ERR, MODERATE_ERR, SEVERE_ERR};

void error_msg (enum error_type);

void main (void)
{
enum error_type error_level;

for (error_level = NO_ERR; error_level <= SEVERE_ERR; error_level++)
{
error_msg (error_level);
}
printf ("\nEnd of program\n");
}

79
void error_msg (enum error_type error)
{
printf ("There is ");
switch (error)
{
case NO_ERR : printf ("no error.\n");
break;
case MINOR_ERR : printf ("a minor error.\n");
break;
case MODERATE_ERR : printf ("a moderate error.\n");
break;
case SEVERE_ERR : printf ("a severe error.\n");
break;
}
}
This program tests the error_msg() function by looping through the various enumerated error_type values. Each loop
will call the error_msg() function and pass the current error_type value to it. The error_msg() function will then print
a message based upon the error_type value passed to it. When this program is run the output will be as follows:
There is no error.

There is a minor error.
There is a moderate error.
There is a severe error.

End of program.
The following program exercises the Boolean_msg() function in a manner similar to the previous program, looping
through the enumerated Boolean values and passing them to the Boolean_msg() function.

typedef enum Boolean {FALSE = 0, TRUE};

void Boolean_msg (enum Boolean); /* Prototype for Boolean_msg() function */

void main (void)
{
enum Boolean logic_state;

for (logic_state = FALSE; logic_state <= TRUE; logic_state++)
{
Boolean_msg (logic_state);
}
}
80

void Boolean_msg (enum Boolean bool_val)
{
printf ("The logic state is ");
switch (bool_val)
{
case FALSE : printf ("FALSE.\n");
break;
case TRUE : printf ("TRUE.\n");
break;
}
}
When this program is run the output will be:
The logic state is FALSE.

The logic state is TRUE.
The program below uses the cube() function to calculate the cube of an entered value. The program first requests the
user to enter a number. It then passes the value of the entered number to the cube() function, copies the return value
into the float variable cubed, outputs the result, and terminates the program.

float cube (float); /* Prototype for cube() function. */

void main (void)
{
float number,
cubed;

printf ("Enter a number: ");
scanf ("%f", &number);
cubed = cube (number);
printf ("The cube of %f is %f\n", number, cubed);
}

{
float result = 0;

result = base * base * base;
return result;
}
Assume that the number 1.2 is entered. When the program is run the output will be:
81
Enter a number: 1.2

The cube of 1.200000 = 1.728000

End of program.
The program below uses the Pythagoras() function to calculate the hypotenuse of a right triangle from the values of
two sides entered by the user. Because the function uses the C sqrt() function the program includes the math.h
reference so that the compiler can access the function and compile the program.
#include <math.h> /* Required for sqrt() function. */

float Pythagoras (float, float); /* Prototype for Pythagoras() function. */

void main (void)
{
float x, y, z;

printf ("Enter the length of side 1: ");
scanf ("%f", &x);
printf ("Enter the length of side 2: ");
scanf ("%f", &y);
z = Pythagoras (x, y);
printf ("The hypotenuse of %f and %f is %f\n", x, y, z);
}

float Pythagoras (float x_side, float y_side)
{
float hypotenuse;

hypotenuse = sqrt (x_side * x_side + y_side * y_side);
return hypotenuse;
}
Assume that the values 1.2 and 0.5 are entered at the prompts. When the program is run the output will be:
Enter the length of side 1: 1.2

Enter the length of side 2: 0.5
The hypotenuse of 1.200000 and 0.500000 is 1.300000

End of program.
82
12.5 Using Pointers with Functions
The function examples discusses have returned a single value, which is all that C permits. Suppose, however, that
the function must return more than one value? One solution would seem to be modifying and passing back values in
the parameter list, as shown below:

void doomed_to_fail (int, int); /* Prototype for doomed_to_fail() function. */

void main (void)
{
int num1 = 3,
num2 = 4;

printf (“num1 = %d, num2 = %d\n”, num1, num2);
doomed_to_fail (num1, num2);
}

void doomed_to_fail (int number1, int number2)
{
printf (“number1 = %d, number2 = %d\n”, number1, number2);
printf (“Squaring numbers...\n”);
number1 *= number1;
number2 *= number2;
printf (“number1 = %d, number2 = %d\n”, number1, number2);
}
At first it would seem that this would square the values of number1 and number2, but unfortunately (as the name of
the function indicates) this method does not work. When the program is run, the output will be:
num1 = 3, num2 = 4

number1 = 3, number2 = 4
Squaring numbers...
num1 = 3, num2 = 4
The program output is exactly as desired until the last line. Although the output clearly shows that the values passed
to the doomed_to_fail() function were squared, the value passed to it by main() were not. This is precisely because
values in the variables, and not the variables themselves were passed to the function . When the program passed the
values of num1 and num2 it created copies of those values called number1 and number2, and those copies are all
that the doomed_to_fail() function can access or affect. The originals, which were declared in main(), is accessible
only within main. Similarly, variables declared within other functions and their parameter lists exist only within
those functions. On the most basic level you can think of the beginning and end braces of a function as boundaries
beyond which function variables do not exist and functions cannot reach. This creates a basic problem with
functions modifying values that are passed to them.
Fortunately C has a solution to this difficulty, which was actually revealed when the scanf() function was first
introduced. The solution is to pass the addresses of variables to the function, which can then use these addresses as
pointers back to the values. Even though C still creates copies of the addresses when the program passes the values
83
to a function these addresses will still reference the same location. Using a copy of the address of a variable will still
modify that variable. The following example demonstrates how to modify the doomed_to_fail() program to use
addresses, which can be passed to functions and used as pointers. Note that the data types for the modified
this_works() function and prototype parameter list must be changed from int to int *, or pointer to int.

void this_works (int *, int *); /* Prototype for this_works() function. */

void main (void)
{
int num1 = 3,
num2 = 4;

this works (&num1, &num2);
}

void this_works (int *number1, int *number2)
{
printf (“number1 = %d, number2 = %d\n”, *number1, *number2);
printf (“Squaring numbers...\n”);
*number1 *= *number1;
*number2 *= *number2;
printf (“number1 = %d, number2 = %d\n”, *number1, *number2);
}

Now when the program is run the addresses of the variables num1 and num2 are passed to the function. The program
creates copies of these addresses and loads them into the int * variables number1 and number2, which the
this_works() function uses to access and modify the contents of *number1 (or num1) and *number2 (or num2). When
this program is run the output will be:
num1 = 3, num2 = 4

Squaring numbers...
num1 = 9, num2 = 16
Another example illustrates passing addresses to a function to copy the contents of one structure to another. In
reality a functions is not really necessary, because the assignment operator (=) can be used to copy the contents of
one structure to another structure of the same time.

typedef struct
{
84
float magnitude;
float angle;
} polar_type;

void show_polar (polar_type); /* Prototype for show_polar() function. */
void polar_cpy (polar_type *, polar_type *); /* Prototype for polar_cpy() function. */

void main (void)
{
polar_type vector1, vector2;

vector1.magnitude = 5.0;
vector1.angle = 0.927295;
show_polar (vector1);
vector2.magnitude = 0.0;
vector2.angle = 0.0;
polar_cpy (&vector1, &vector2);
}

void show_polar (polar_type polar)
{
printf ("Magnitude = %f, Angle = %f\n", polar.magnitude,
polar.angle);
}

void polar_cpy (polar_type *polar1, polar_type *polar2)
{
(*polar2).magnitude = (*polar1).magnitude;
(*polar2).angle = (*polar1).angle;
}
When this program is run the output will be:
Magnitude = 5.000000, Angle = 0.927295

Magnitude = 0.000000, Angle = 0.000000
Magnitude = 5.000000, Angle = 0.927295
Magnitude = 5.000000, Angle = 0.927295
Magnitude = 5.000000, Angle = 0.927295

Because programs use pointers to structures fairly often C provides an alternate method to use a pointer to access the
fields of a structure. In place of
(*struct_ptr).field
85
programs can use the alternate notation
struct_ptr-‐>field
when using pointers to structures. The code below shows alternate form of polar_cpy() using this pointer notation.
void polar_cpy (polar_type *polar1, polar_type *polar2)

{
polar2-‐>magnitude = polar1-‐>magnitude;
polar2-‐>angle = polar1-‐>angle;
}
86
Section 13 - In Conclusion
13. In Conclusion
C is a very complex language, far too complex for a short tutorial such as this to cover more than the essentials. This
tutorial has attempted to introduce and cover enough features in C for the user to write functionally useful programs
and provide enough information so that the reader can further explore C independently, both through other
references on C and hands-on experimentation writing, compiling, and running C programs. The best approach for
become more proficient with C programming is to begin with basic functional code, selectively modify the code,
and see how those code modifications affect how the program operates. You will probably find that each new
concept and feature you learn will make other features even easier to learn and apply. Writing programs will also
improve your understanding of other programming languages and how software and hardware interact.
Good luck and enjoy the journey!
87

C Tutorial

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C Tutorial

Uploaded by

Copyright:

Available Formats

Programming in C

What Programming in C Is Not

How to Use This Tutorial

1.2 The HELLO.C Program

1.2.1 Program Comments

1.2.2 Blank Lines

1.2.3 Preprocessor Directives

1.2.4 Header Files

int _RTLENTRY _EXPFUNC printf(const char * __format, ...);

1.2.5 The Main Function

1.2.6 The printf() Function

retval = printf (“Hello, world\n”);

1.2.7 Coding Style

2. Elementary Data Types

2.2 Elementary Data Types in C

short int short_var; /* “short short_var;” is also acceptable */

long int long_var; /* “long long_var;” is also acceptable */

char keypress /* A variable to hold a single keypress */

2.2.3 Floating Point Values

float float_var /* Single-­‐precision floating point value */

double double_var /* Double-­‐precision floating point value */

2.3 Other Data Types

3. Input and Output

3.2 The scanf() Function

3.2.1 The Basic scanf() Format

scanf (“%<variable type>”, &<variable>)

c ASCII character value

3.2.2 Using the scanf() Function

#include <stdio.h> /* Required for printf() and scanf() functions */

#include <stdio.h> /* Required for printf() and scanf() functions */

3.3 The printf() Function

3.3.1 The Basic printf() Format

printf (“%<variable type>”, <variable>)

c ASCII character value

3.3.2 Using the printf() Function

Integer = 123 and float = 123.4

Integer = +123 and float = +123.4

3.4 Combining the scanf() and printf() Functions

3.4.1 Verifying scanf() with printf()

#include <stdio.h> /* Required for printf() and scanf() functions */

#include <stdio.h> /* Required for printf() and scanf() functions */

Please enter a decimal integer value: 100

Similarly, a program to convert hexadecimal values into decimal is show below.

#include <stdio.h> /* Required for printf() and scanf() functions */

4.2 Arithmetic Operators in C

4.2.1 Unary Arithmetic Operators

printf (“The number is %d.\n”, ++int_var);

printf (“The number is %d.\n”, int_var++);

The number is 7.

4.2.2 Binary Arithmetic Operators

The binary arithmetic operators in C consist of the following:

is 4, because 5 divides evenly into 14 twice with a remainder of 4.

4.3 Order of Arithmetic Operations in C

++, -­‐-­‐ Increment and decrement by one operators

4.4 Some Programming Examples with Arithmetic Operators

4.4.1 Demonstration of Arithmetic Operations

#include <stdio.h> /* Required for printf() and scanf() functions */

Please enter integer 1: 2

4.4.2 Quadratic Formula Evaluation

#include <stdio.h> /* Required for printf() and scanf() functions */

Please enter coefficient a: –1.5

printf (“\n\nThe answer is %4.1f\n”, answer);

4.5 Convenient Operator Shortcuts

int_val = int_val * 6;

float float_var /* Single-‐precision floating point value */

double double_var /* Double-‐precision floating point value */

++, -‐-‐ Increment and decrement by one operators