Imperative Programming

Introduction to C

The Imperative Programming Paradigm

The program is viewed a (sequential) list of instructions, executed in a certain
order
The order of excution is normally fully deterministic
Search has to be programmed explicitely
Instructions change the (global) state of the program by
Destructively changing the value of some variable (memory location)
Changing the control flow of the program
Non-destructive computations, as e.g. the evaluation of side-effect free expression,
are only temporary, and serve just to determine how to change the global state

79

State
The state of a running program can be split into:
Values stored in variables accessible to the program (including dynamically
allocated data structures, if the language allows for those)
Control flow state, including the current point of control (sometimes called
the program counter), and, in languages that allow for recursion, the calling
sequence for functions and procedures (normally represented by some kind of
stack
Assignments change the first part of the state, flow control constructs change
the second part

80

History and Background

Imperative language naturally arose from the requirements of early hardware
Most computers ever build have an inherently imperative paradigm: Instructions modify registers (including the PC) and memory locations
As a consequence, all (existing) assembler languages can be seen as imperative
FORTRAN was the first higher-level language, and is perhaps the best example
of a purely imperative language
FORTRAN originally allowed no recursion, and had few control flow statements
except for goto and (non-recursive) procedure activation
Problems with the design of large, reliable systems led to the rejection of
unstructured use of goto (Dijkstra, Go To Statement Considered Harmful,
CACM, March 1968) and the desire for more structured languages, ultimately
resulting in
The Algol family, leading Pascal and Modula-2, of designed languages,
introducing many important features
The C family of hacked languages, still going strong and having significant
influence on modern object-oriented languages like C++ and Java
81

Design Criteria
Efficiency
Imperative languages map naturally to past and current hardware (and are
likely to map well onto hardware build in the forseeable future, too)
This advantage has generally made imperative language designers striving for
efficiently executable language features
Understandability/Structure
Static language features should illustrate the dynamic behaviour of the program,
i.e. it should be easy to understand the dynamic control flow from the static
program text
The language should support abstraction and infomation hiding, i.e. a separation of interface and implementation for new procedures and datatypes

82

Design Criteria II
Scope of Application
Language designers aim at a wide range of applications
Since imperative languages map well to hardware, some language include low
level constructs for manipulating hardware directly
On the other hand, wide portability of code written in the language is achieved
by a strong abstraction from the hardware
Imperative programming is still the predominant programming paradigm, followed
by its off-shot, object-oriented programming

83

Statements and Expressions

An imperative program is a sequence of statements, possibly broken up into
individual procedures or functions
We can distinguish between two types of statement:
Actions directly change the value of an explicitly accessible element of the
state. The prototypical action is an assignment, giving a new value to a
variable
Flow control statements only change implicitely stored elements, such as the
program counter or the stack. The include if and goto
In most languages, expressions are a distinct from statements
Expressions do not directly change the state of the computation (although
they may have side effects that do)
Rather, expressions provide values to be used in actions

84

C
C is a structured, imperative/procedural language, originally developed in 1972
to implement UNIX
C actions and basic data types allow low level programming
Most C datatypes correspond to machine datatypes
C has a (non-standardized, but in practice universal) mechanism for directly
accessing specific memory regions
Cs type system allows the same abstractions as the Algol family, but is more
pragmatic
C supports enough important structuring elements to allow the implementation
of large systems, again often in a very pragmatic way
The C language has a small core, based on just a few principles
The core language can be learned fast, and the average programmer uses a
large part of it
Much functionality is added by (portable and standardized) libraries
85

C: Basic Building Blocks

A C proramm consist of
Variables (that can store values of certain types)
Functions (parameterized subroutines that can return values, allowing us to
use abstraction at the algorithm level)
Type definitions, introducing new datatypes and thus allowing us to introduce
abstractions at the data representation level
C allows us to separate the declaration of a variable/function/type from its
definition
Typically, declarations tell some things about the interface for interactions with
the environment
Definition describe the internal implementation of the object
Definitions are compiled into code or cause memory to be reserved
Entities can be declared multiple times (as long as the declarations are compatible), but can be defined only once

86

A first C program
Consider the following C program
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf("Hello World!\n");
return EXIT SUCCESS;
}

It defines a single function, called main(), and taking no arguments

If compiled and executed, it will print "Hello World!" to the screen

87

C Comilation Environment
A C program typically is build from multiple source files
Header-Files, containing mostly declarations (traditionally with the suffix .h)
Implementation files (suffix .c)
A combination of header file (defining the interface) and implementation file can
be seen as a module
C does not have an elaborate module system
Instead, it achieves a similar result using the combination of the C preprocessor
(which physically combines header files and implementation files) and the
languages scoping rules

88

The C Compilation Model

Headers
(Declarations)

Headers
(Declarations)

Headers
(Declarations)

Headers
(Declarations)
C Preprocessor

Sources
(Definitions)

Sources
(Definitions)

Sources
(Definitions)
Compiler

Object
Files

Object
Files

Object
Files

System
Library

System
Library

Linker
Includes

Executable

Translates into

RTE
(Shared libs)

Is combibed into

89

C Fasttrack: Statements, Blocks, and Expressions

C programs are mainly composed of statements
In C, a statement is either:
An expression, followed by a semicolon ; (as a special case, an empty expression is also allowed, i.e. a single semicolon represents the empty statement)
A flow-control statement (if, while, goto,break. . . )
A block of statements (or compound statement), enclosed in curly braces {}.
A compound statement can also include new variable declarations.
Expressions compute values and may have side effects that change the global
state of the computation. An expression is either:
Elementary (a variable, constant, or function call) or
A parenthesized expression or
built by applying an operator to the right number of subexpressions

93

C Fasttrack: Basic Data Types

C supports (among others) the following important basic data types
char can store small integer numbers. It is typically 8 bit wide and used to
store character in the characterset used (often ASCII)
int stores integer numbers that correspond to the natural machine word of
the target architecture. Typically, int can store 32 bit values
long can store large integer numbers. However, on most common current
implementations, long is equivalent to int
float can store single precision floating point numbers (typically 32 bit, with
one bit for the sign, 23 for the mantissa, and 8 bits for the exponent)
double can store double precision floating point numbers (typically 64 bit, 11
bits exponent, 52 bits of mantissa)
All numerical types can be freely mixed in expressions
If different types are combined in an expression, the smaller type is promoted
to the larger and the result is of the larger type
If assigned to a smaller type, values are truncated (integers) or rounded (floats)

94

C Fasttrack: Variables and Assignments

Variables of a certain type correspond to locations in memory that are capable of
storing a value of that type
A valid variable name starts with a letter or underscore ( ), and may contain any
sequence of letters, underscores, and digits. Reserved words (if, while,...)
cannot be used as variable names
Capitalization is significant a variable is different from A Variable
Variable declarations:
A (simple) variable declaration has the form <type> <varlist>;, where
<type> is a type identifier (e.g. int), and <varlist> is a coma-separated list
of variable names
A variable declared in a block is (normally) visible just inside that block
The value of a variable (more general, of a lvalue) is changed with the assignment
operator = (note, single equality sign)
a = <expr> is an expression with the value of <expr>
As a side effect, it changes the value of a to that of <expr>
95

C Fasttrack: Some Operators

Operator
!

Argument Types
All basic and pointers

Binary *
/
%
+,<, <=,
>=, >

Numerical
Numerical
Integer type
Numerical, (Pointer)
Numerical and pointers

==, !=

All basic and pointers

&&

All basic and pointers

||

All basic and pointers

All basic, pointers, structs

Description
Logical negation, 1 if arg is 0, 0
otherwise
Multiplication
Division (truncates on int)
Division rest
Addition and subtraction
Size/Adress comparison
Note: All relational operators return 0 if false, 1 if true
Equality (note two equal signs!),
inequality
Logical and, 1 if both arguments
are not zero, 0 otherwise
Logical or, 0 if both arguments are
zero, one otherwise
Assignment operator

Note: Table is ordered by precedence, entries between lines share precedence

96

C Fasttrack: Example 1 (Temperature Conversion)

/* A program that prints a Fahrenheit -> Celsius conversion table */
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int fahrenheit, celsius;
printf("Fahrenheit -> Celsius\n\n");
fahrenheit = 0;
while(fahrenheit <= 300)
{
celsius = (fahrenheit-32)*5/9;
printf("%3d
%3d\n", fahrenheit, celsius);
fahrenheit = fahrenheit + 10;
}
return EXIT_SUCCESS;
}
97

C Fasttrack: Simple I/O

The C standard guarantees that each program has three I/O streams open when
it starts running:
Standard Input or stdin is used for normal input
Standard Output or stdout is used for all normal output
Standard Error or stderr is used for out of band output like warnings or error
messages
Under UNIX, by default all three are connected to your terminal, i.e. stdin
receives your keyboard input and all output goes to your screen
printf() is a function for formatted output and prints to stdin
printf() is variadic (it can receive 1 or more arguments)
The first argument is the control string, containing plain characters (copied to
output) and conversion specifiers, starting with %
Each conversion specifier corresponds to an additional argument, and is replaced by a representation of the corresponding value
Example: "%3d" prints the decimal representation of an integer value, using
at least three characters
For details read man 3 printf on one of the lab machines
98

C Fasttrack: Character-Based I/O

Reading characters from stdin: int getchar(void)
getchar() returns the numerical (ASCII) value of the next character in the
stdin input stream
If there are no more characters available, getchar() returns the special value
EOF that is guaranteed different from any normal character (that is why it
returns int rather than char
Printing characters to stdout: int putchar(int)
putchar(c) prints the character c on the stdout steam
(It returns that character, or EOF on failure)
printf(), getchar(), putchar(), and EOF are declared in <stdio.h> (a
standard library header) and provided by the standard library

99

C Fasttrack: Example 2 (Copying)

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int c;
while((c=getchar())!=EOF)
{
putchar(c);
}
return EXIT_SUCCESS;
}

Copies stdin to stdout to make a a file copy, use

ourcopy < file > newfile

100

Flow Diagrams
Flow diagrams give a graphical representation of the control flow for a program
or construct
Elements:
Entry point/Exit Point: This is where
the conrol flow starts or ends
Statement (sequence): Represents an
arbitrary sequence of statements, executed sequentially

true

Conditional branch: Evaluates the expression E, if true, control follows the

arrow labeled true, otherwise it follows
the other arrow

101

Conditional Execution: if
true
E

If E evaluates to true, then execute S (else skip it)

C Syntax:
if(E)
S
where E is any valid expression and S is an arbitrary statement (including a block
of statements, delimited by curly braces)

102

Alternatives: if/else
true
E

S1

S2

If E evaluates to true, then execute S1, else execute S2

C Syntax:
if(E)
S1
else
S2
where again S1 and S2 are arbitrary statements, including statement blocks
103

Multiple Alternatives
Often, a program has to select between many alternatives, only one of which is
applicable:

E1

true

E2

true

E3
true

S1

S2

S3

S4

This can lead to a

cascade of ifs:
if(E1)
S1
else
if(E2)
S2
else
if(E3)
S3
[else
S4]

Preferred form:
if(E1)
S1
else if(E2)
S2
else if(E3)
S3
[else
S4]

The right hand version is not only more compact, but also shows that the alternatives
are at the same level of abstraction.
104

Loops
A loop repeatedly executes the same statements
Programming languages can support looping either by
A combination of arbitrary branching (goto) and conditional execution or
with dedicated loop constructs
Important questions about loop constructs:
Does the loop always terminate (after a predetermined number of repetitions)?
If a program (or program segment) only contains loop constructs guaranteed
to terminate, overall program termination is guaranteed!
Potentially infinite loops are necessary for full Turing completeness
Potential infinite loops also are (practically) indispensibe for server-type
programs or programs that read arbitrary sized input
Is the loop body executed at least once or can it be skipped totally?
Is the loop single entry/single exit?
Single entry/single exit allows us to argue about program correctness using
loop invariants (assertions about the state that always true at a certain
position in the loop)
111

Lazy Loops: while

A while-loop is controlled by a controlling expression at
the top
If this expression evaluates to true, the body of the
loop is executed and control returns to the controlling
expression
If the expression evaluates to false, the body is
skipped, and control is transferred to the first statement following the expression.

E
true

Syntax in C:
while(E)
S
S can be a single statement (even the empty statement) or a block of statements

112

The Initialize-and-Update Problem

Initialize and update in Pascal-like languages:
element := read();
while valid(element) do begin
S;
element := read()
end
Problem: Elements are read at two disjoint positions, making debugging,
understanding and maintaining harder
C-Like languages allow assignments in expressions:
while (valid((element=read()))){
S;
}
As a result, while-type loops (including the C-Style for loop, see below) are
used much more often in C than in Pascal
113

Eager Loops (1): repeat/until

An alternative loop construct tests the controlling expression after the body of the loop has been executed
In many imperative languages, such a loop has the
form of a repeat-until loop:
S

repeat
S
until E;
The body of the loop is executed at least once
After the body has been executed, the controlling
expression is evaluated
The loop is terminated, if the controlling expression
evaluates to true, otherwise control returns to the
first statement of the body

E
true

114

repeat/until and the initialize-and-update-problem

Note that repeat/until allows loops like the following:
repeat
element := read();
if valid(element) then
do something with element
end
until not(valid(element))
This again localizes the read() in one place!

115

Eager Loops (2): do/while

C does not support repeat/until, but a slight variation: do/while
As in repeat/until, the controlling expression is
evaluated at the end of the body
However, the loop terminates if the expression evaluates to false

true
E

Syntax:
do
S
while(E);

116

Example: Uniq
We are looking for a program that eleminates successive occurences the same
element from a sequence
Eample: 1 1 1 2 3 4 4 1 2 2 = 1 2 3 4 1 2
Design idea:
We consider the original sequence as a sequence of sequences of equal characters (where many of the subsequences may have length 1)
Whenever we encounter a new subsequence, we print the first element and
skip all following elements of the same type

117

Uniq Example: Code

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char first, next;
first = getchar();
while(first!=EOF)
{
putchar(first);
do
{
next = getchar();
}
while(next == first);
first = next;
}
return EXIT_SUCCESS;
}

118

Finite Iteration: Classical for

Many programming languages offer for-constructs for finite iteration
Pascal: for i:=<init> to <limit> do S (alternative: downto)
Iterates over integer values between <init> and <limit>
AWK: for(i in <array>)
Iterates over all keys in an associative array
Sinclair BASIC: for i=<init> to <limit> step <step>;S;next i
As Pascal version, but allows for a non-unit stride
Note: i is called the loop variable or index variable (and can of course be any
normal variable name)
Common idea: The loop variable takes on a new value for each successive
traversal of the loop, the loop terminates, if all relevant values have been
processed

119

Classical for continued

Important questions:

What happens if the loop variable is changed in the loop body

What happens if variables occuring in <limit> are modified in the loop body?
What is the value of the loop variable after termination?
Is the order of values for the loop variable defined?

Pascal answers:
It is illegal to modify the loop variable in the loop
The limit is only evaluated once (before entering the loop), i.e. modifiying any
variables does not change the loop behaviour
The value of the loop variable after the loop is undefined
The possible values are reached sequentially (increasing for to, decreasing for
downto)
AWK answers:
If you do stupid things, you have to live with the result (everything is
implementation-defined in a cryptic way)
120

C-Style for
A for loop in C is a while-type loop which allows us to combine initialization,
controlling expression and updating in one place
Syntax:

for(E1; E2; E3)

S
When the loop is entered for the first time, E1 is evaluated (the value is not
used, but it typically is an assignment expression initializing a loop variable)
Then E2 is evaluated. If it is false, the body is skipped and the loop terminates.
If it is true, the body is executed
After the body has been executed, E3 is evaluated. Again, the value is
discarded, but E3 typically is another assignment. Control then returns to the
top of the loop

The for statement in C is not restricted to finite iteration

It generalizes while: for(;E;)S is equivalent to while(E)S
It also generalizes Pascal for: for(i=<init>; i<=<limit>;i=i+1)S

121

Example: Uniq with for

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char first, next;
for(first = getchar(); first!=EOF; first = next)
{
putchar(first);
do
{
next = getchar();
}
while(next == first);
}
return EXIT_SUCCESS;
}

122

Example: Uniq with for

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char first, next;
for(first = getchar(); first!=EOF; first = next)
{
putchar(first);
do
{
next = getchar();
}
while(next == first);
}
return EXIT_SUCCESS;
}

125

Search in Loops
A frequent use of loops is to search for something in a sequence (list or array) of
elements
First attempt: Search for an element with property P in array
for(i=0; (i< array_size) && !P(array[i]); i=i+1)
{ /* Empty Body */ }
if(i!=array_size)
{
do_something(array[i]);
}
Combines property test and loop traversal test (unrelated tests!) in one
expression
Property test is negated
We still have to check if we found something at the end (in a not very intuitive
test)
Is there a better way?
126

Early Exit: break

C offers a way to handle early loop exits
The break; statement will always exit the innermost
(structured) loop (or switch) statement

E1

true

Example revisited:
S1

for(i=0; i< array_size; i=i+1)

{
if(P(array[i])
{
do_something(array[i]);
break;
}
}
I find this easier to read
Note that the loop is still single entry/single exit,
although control flow in the loop is more complex

true
E2

S3

S2

while-loop with break

127

Selective Operations and Special Cases

Assume we have a sequence of elements, and have to handle them differently,
depending on properties:
for(i=0; i< array_size; i=i+1)
{
if(P1(array[i])
{
/* Nothing to do */
}
else if(P2(array[i]))
{
do_something(array[i]);
}
else
{
do_something_really_complex(array[i]);
}
}

Because of the special cases, all the main stuff is hidden away in an else
Wouldnt it be nice to just goto the top of the loop?
128

Early Continuation: continue

A continue; statement will immediately start a new
iteration of the current loop

E1

For C for loops, the update expression will be

evaluated!
E2

Example with continue:

true

<body>

for(i=0; i< array_size; i=i+1)

{
if(P1(array[i])
{
continue;
}
if(P2(array[i]))
{
do_something2(array[i]);
continue;
}
do_something_really_complex(array[i]);
}

EC

true

<body>

E3

for loop with continue

129

Arbitrary Control Flow: goto

Most modern languages still support arbitrary transfer of the control (often only
within a function) via goto
Typically, a program can contain labels of the form label: <statement>
A goto label; then transfers contol to the statement following the label
Note: Both C and Pascal use this syntax
goto is never strictly necessary
It can always be replaced by using apropriate structured programming constructs
However goto can be useful in certain (rare) circumstances:
Building state machines (e.g. finite automata): Each label corresponds to
a state, goto is used to implement transistions (particularly important for
automatically generated code)
Common error handling for different cases
130

Implementation Issues: Loops

Structured loop constructs are hard and expensive to implement directly:
Since loops are defined by textual scoping rules, it is necessary to search for
the begin of a loop
Hence, machine instruction sets for modern microprocessors do not typically
direcly support any flow control constructs except for conditional and unconditional branching (limited if and goto)
However, high-level loop constructs are compiled down to efficient constructs
There is normally no efficiency reason to use goto!

131

Example: Implementing for

for-loop
for(E1; E2; E3)
{
if(EC)
{
continue;
}
S;
}

Equivalent low-level loop

E1;
loop:
if(!E2)
{
goto end;
}
if(EC)
{
goto update;
}
S;
update: E3;
goto loop;
end:

132

Selection of Alternatives
Often, a program has to select between multiple alternatives based on the value
of a single variable:
if(blip == weather_ballon)
{
ignore();
}
else if(blip == airplane)
{
complain_to_ATC();
}
else if(blip == russian_missile)
{
press_red_button();
}
else
{
ufo_alarm();
}

133

Case Distinctions
Many languages offer a dedicated programming construct for case-distinctions
like that
Dedicated constructs may make code easier to read
In many cases, it can be compiled into faster code than a more general
if/else chain
C provides the switch statement:
switch(E)
{
case val1: S1;
case val2: S2;
...
default: Sd;
}

134

The Switch-Statement
switch(E)
{
case val1: S1;
case val2: S2;
...
default: Sd;
}
E has to be an integer-valued expression (this includes enumeration types)
val1, val2,. . . have to be constant integer expressions
E is evaluated and the result is compared to each of the constants after the case
labels. Execution starts with the first statement after the matching case. If no
case matches, execution starts with the (optional) default case.
Note: Execution does not stop at the next case label! Use break; to break out
of the switch
135

Example: switch
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main(void)
{
int c;
while((c=getchar())!=EOF){
switch(c)
{
case \n: printf("\\n"); break;
case \t: printf("\\t"); break;
case \r: printf("\\r"); break;
default:
if(isprint(c))
{ putchar(c); }
else
{ printf("\\%03o",c); }
break;
}
}
return EXIT_SUCCESS;
}
136

Potential Problems with C switch:

switch(blip)
{
case weather_ballon
ignore();
case airplane:
complain_to_ATC();
case russian_missile:
press_red_button();
default:
ufo_alarm();
}

As usual, C gives you enough rope to hang yourself!

You can use this to handle special cases and fall through to a common part
It also is useful to provide the same code for many labels
Other languages execute exacly one statement (or block of statements) for a
single label

137