Computer Programming I

UP ITTC
AY 2009-2010
 Computer Programming I
Introduction: Computer Programming

Lesson 1: Overview of Programming

Languages

Lesson 2: Introduction to C Programming

Lesson 3: C Fundamentals

Lesson 4: Control Structures
Computer Programming I

Lesson 5: Subprograms

Lesson 6: Arrays, Strings and Pointers

Lesson 7: Command-Line Arguments

Lesson 8: Structures

Lesson 9: Dynamic Memory Allocation

Lesson 10: File Handling
 Preface

Prerequisites
Computer Systems 1
Knowledge of algorithms

Related Publications
The C Programming Language 2nd Edition

Brian W. Kernighan, Dennis M. Ritchie
C by Dissection 4th Edition

Al Kelly, Ira Pohl
 Overview

This course introduces computer
programming using the language C.
 Objectives
At the end of this course, you should be able
to:

Understand the methodology for
implementing a program.

Understand the programming elements
involved in implementing a program in C.

Understand the creation and reuse of parts
of a program.
Duration

Lecture: 24 hours (4 days)

Workshop: 36 hours (6 days)
Schedule
Day 1

Lesson 1: Overview of Programming
Languages

Lesson 2: Introduction to C Programming

Lesson 3: C Fundamentals
 Schedule
Day 2

Lesson 5: Control Structures

Lesson 6: Subprograms
 Schedule

Day 3

Lesson 8: Array, Strings and Pointers

Lesson 9: Command-Line Arguments

Lesson 10: Structures
Schedule

Day 4

Lesson 10: Dynamic Memory Allocation

Lesson 11: File Handling
 Schedule

Days 5 - 7:
 Workshop: Machine Problem Part 1

Days 8 – 10:
 Workshop: Machine Problem Part 2
 Departmental Exam
 Course Requirements

Machine Exercises 20%

Machine Problem Part 1 20%

Machine Problem Part 2 30%

Long Exam (Departmental Exam) 30%
Overview of Programming
Languages

Lesson 1
 Introduction

Definition of Programming Languages

Levels of Programming Languages
 Machine Language
 Assembly Languages

 High-level Languages

 Very High-level Languages

 Natural Languages
 What is a Programming
Language?

A programming language is a set of rules
for instructing the computer what
operations to perform.
 Levels of Languages

Machine Language

Assembly Languages

High-level Languages

Very High-level Languages

Natural Languages
 Machine Language

Machine language is the only language
understood by a computer

Consists of binary numbers (1s and 0s)

 Assembly Languages

Assembly language is a low level
message which uses mnemonic codes
and abbreviations that are easy to
remember

We use an assembler in order to
convert it from assembly language to
machine language
 High-level Languages

High-level languages are programming
languages that are written in English-like
manner.

Examples: C, C++, Java, Pascal

We use a compiler in order to convert it
to machine language.
 Very High-level Languages

Very high-level languages are essentially
shorthand programming languages.

Also called fourth-generation languages

or 4GLs.
 Lesson Review

A programming language is a set of rules for
instructing the computer what operations to
perform.

There are five generations/levels of languages:
Machine Language, Assembly Languages, High-
level Languages, Very High-level Languages and
Natural Languages.

An assembler is used to convert assembly
language to machine language.

A compiler is used to convert a high-level language
to machine language.
Introduction to C
Programming

Lesson 2
 Introduction

Introduction to C

Characteristics of C

Elements of a C Program

Our First C Program: Hello World

Compiling & Running our first C Program

Phases of a C Program
The “C” Programming Language

A high-level general-purpose
programming language

Developed by Brian Kernighan and

Dennis Ritchie of AT&T Bell Labs in 1972
 Characteristics of C

C is a small language.

C is the standard development language
for personal computers.

C is portable.

C is modular.

C is the basis for C++ and java.
 Elements of a C Program

Identifiers
a name in a C program
 a string of letters, digits and underscores, provided that
the string doesn’t start with a digit.
 Case-sensitive

 Examples of VALID identifiers

_hello IamAnIden1234 _1234

 Example of INVALID identifiers

123hello dDAT.1 file-name

 Elements of a C Program

Reserved Words/Keywords
 words that have predefined meanings and
cannot be used as names for anything else.
 C has 32 keywords, these are:
 Our First C Program
/**
* Hello.c
* This is my very first C program and I'm
* excited about it :-)
**/
#include <stdio.h>
int main( void )
{
/*print text to screen*/
printf("Hello world!");
}
  This is a Comment.
Comments are used for
Our First C Program 
documentation purposes
and does not affect the
program flow.
/**
* Hello.c
* This is my very first C program and I'm
* excited about it :-)
**/
#include <stdio.h>
int main( void )
{
/*print text to screen*/
printf("Hello world!");
}
 Our First C Program  This is a Preprocessor or
Precompiler directive.
 A Preprocessor or
Precompiler directive are
/** lines in C that are processed
* Hello.c before compiling the code.
* This is my very first C program and I'm
* excited about it :-)
**/
#include <stdio.h>
int main( void )
{
/*print text to screen*/
printf("Hello world!");
}
 Our First C Program
 Define a block of commands
called main.
/**  main is a special block – it is
* Hello.c where the program starts
* This is my very first Crunning.
program and I'm
* excited about it :-)  Every C program must have a

**/ single main block.

#include <stdio.h>
int main( void )
{
/*print text to screen*/
printf("Hello world!");
}
 Our First C Program
/**
* Hello.c
* This is my very first C program and I'm
* excited about it :-)
**/
#include <stdio.h>
 This is also a comment.
int main( void )
{
/*print text to screen*/
printf("Hello world!");
}
 Our First C Program

The printf function is a
standard output function
/** which takes in a string as its
* Hello.c function argument, and
* This is my very first Coutputs
programit to theand
screen.I'm
* excited about it :-)
This is an example of a
statement, it ends with a
**/
semicolon.
#include <stdio.h>
int main( void )
{
/*print text to screen*/
printf("Hello world!");
}
 Compiling our first C Program

Compiler
 Used to convert a high-level language to
machine language
 gcc – name of the compiler we will use to
compile our C programs
Phases of C Programs:
 Edit (C program file
names should end with
the .c extension)
 Preprocess
 Compile
 Link
 Load
 Execute
 Phases of C Program

Phase 1: Create your program with an editor program

Phase 2: A preprocessor find some preprocessor directives
(#include <stdio.h>) to include other files and perform
various text replacements

Phase 3: Compiler compiles the program into machine
languages (object code != object-oriented programming).

Phase 4: A linker links the object code with the code in
library or other places to produce an executable image.

Phase 5: A loader loads the executable image into memory
(RAM).

Phase 6: CPU executes the program one instruction at a
time.
 Lesson Review

C is a high-level general-purpose programming language
developed by Brian Kernighan and Dennis Ritchie of AT&T
Bell Labs in 1972.

Identifiers are names in a C program. It consists of a string
of letters, digits and underscores, provided that the string
doesn’t start with a digit. It is case-sensitive.

Reserved words or keywords in C, are words that have
predefined meanings and cannot be used as names for
anything else. C has 32 keywords.
Lesson Review

To compile:
gcc <filename.c> -o <outputfile>

To run:
./<outputfile>

6 phases that a C program undergoes:
Edit, Preprocess, Compile, Link, Load
and Execute
 Exercise 1

Write a short but complete C program
that outputs to screen what you feel
about your instructor.
C Fundamentals

Lesson 3
 Introduction

C Program Structure
 Preprocessor/Precompiler directives
 Libraries
 Declarations

Type declarations

Variable/constant declarations

Function/procedure declarations

Main function declarations
 Introduction

Statements and Blocks

Basic Data Types

Constants

Variables

Basic I/O: scanf, printf

Operators
 Arithmetic, Increment/Decrement, Relational, Logical,
Modulo, Assignment, Shortcut
 Precedence
 C Program Structure

Program structure for C programs:

[<preprocessor/precompiler
directives>]
[<declarations>]
<main-function-definition>
[<function-definitions>]
 Preprocessor / Precompiler
Directives

Precompiler directives or preprocessors are
statements in C that are processed before
compilation.

Usually begins with the # symbol perhaps
preceded by white spaces.

They may appear anywhere.

Examples:
#include..
#define...
 Libraries

a collection of useful functions and
symbols that may be accessed by a
program

has a standard header file whose name
ends with the symbols .h

Example:
#include <stdio.h> /*printf, scanf
definitions*/
 Declarations

The following are different types of

declarations in C:

<type declarations> |
<variable/constant declarations>
|
<function/procedure declarations>
 Variable/Constant Declarations

Thesyntax of a variable/constant
declaration is:
[const] <data_type>
<variable/constant_name> [=
<value>];
 Variable/Constant Declarations

Declarations that begin with const are
constant declarations while those that do
not are variable declarations.

Examples:
const age_type age = 22;
const float salary = 54321.20;
char* name, address;
char gender = 'M';
 Function/Procedure
Declarations

Thesyntax of a function/procedure
declaration is:
<return_type>
<function/procedure_name>
(<parameters>)
{
<function/procedure body>
}
 Function/Procedure
Declarations

Declarations whose return type is void are
procedure declarations. Otherwise, they
are function declarations.

Examples:
void greet(void){
printf("Hello there.\n");
}
int add(int x, int y){
return x+y;
}
 Main Function Declaration

Thesyntax of the main function
declaration is:
<return_type> main (<parameters>){
<main_body>
}
Sample Program
 C Statements & Blocks

C Statements are lines of code ending

with a semicolon (;).

Blocks are groups of statements

enclosed in curly braces {}.
 Basic Data Types

C has at least 3 basic data types:

 Character (char)
 Integer (int)
 Floating point numbers (float/double)
 Character Data Type

A character in C is in the form:

'<single character>'

Examples:
'a' (letter a) '1' (number one)
':' (colon) ' ' (space)
'*' (asterisk) '?' (question mark)
'T' (capital T)
 Character Data Type

C has special kinds of characters called
escape sequences.

Here are some of the escape sequences in
C:
'\f' (formfeed) '\\' (backslash)
'\n' (newline) '\'' (single quote)
'\r' (carriage return) '\"' (double quote)
'\t' (horizontal tab) '\ooo' (octal
number)
'\xhh' (hexadecimal number)
 Character Data Type

Are really just integers.
 Character encoding is platform specific.
 ASCII, Unicode, ISO 8859

char
 At least 8 bits (“byte”)

wchar_t
 “Wide character”
 Usually the same as unsigned int (Unicode)
The ASCII Table
 Integer Data Type

Integers have values that are whole numbers.

They can be positive or negative.

The type name for integer data type in C is:
int

Can be written as:
 Decimal -1234 230 +250
 Hexadecimal -0x1234 0x0E6 +0xFA
 Octal -01234 0346 +0372
 Floating Point Data Type

A floating point in C is the data type

whose values are numbers, that, when
written in the usual decimal notation,
have digits after the decimal point.

The type name for floating point data
type in C is:
float

Examples of floating points are:
1.0 0.31416 1E6 4.3E5
 typedef

InC, you can define your own data types
based on existing data types. (alias)

Type declaration using basic data types
has the following syntax:
typedef <data_type> <type_name>;
 typedef

Examples:
typedef char gender_type;
typedef int age_type;
typedef float grade_type;
 Constants

Constants in C are values that never
change throughout the entire program.

Types of Constants in C:
 Integer
 Character
 Floating-point
 String
 Enumeration
 Constants

To declare your own constants:
const <data_type> <constant_name>
= <value>;

Examples:
const char middle_initial = 'C';
const int num_colors = 7;
const float pi = 3.1416;
 Constants

You can also use the #define

preprocessor to declare constants in your
program.

The syntax is:
#define <constant_name> [value]

Examples:
#define Kg_Per_Lbs 0.454545
#define Pi 3.1416
 Variables

Variables,
in C, are objects whose value
may change during the course of a
program’s execution.

A variable in C is declared using the

following syntax:
<data_type> <variable_name> [=
<initial value>];
 Variables

Named area in the computer memory,

intended to contain values of a certain
kind (integers, real numbers,
characters etc.)

They contain the data your program
works with
 Variables Declaration

Before using a variable, one must declare it.

Variables declaration may only appear at the beginning of a
block.

The declaration first introduces the variable type, then its
name.

When a variable is declared, its value is undefined.

int integer;
Type
float small_real;
Identifier
double big_real;
char c1, c2;
 Variables Declaration

Naming rules:
 Letters, digits, underscores

i

CSE_5a

a_very_long_name_that_isnt_very_useful

fahrenheit
 First character cannot be a digit

5a_CSE is not valid!
 Case sensitive

CSE_5a is different from cse_5a
Example: Variable
Declarations

int i, j;
char ch;
float num1 = 5.20, num2 = 7.0;
double d;
Primitive Data Types

char – character (1 byte)
 ‘a’, ‘b’, ‘c’ ..., ‘A’, ‘B’, ‘C’, ...

 ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘0’

 ‘_’ ‘,’ ‘#’ ‘$’ ‘^’ ‘*’ ‘@’ ‘!’ ....

int – integer number (4 bytes).

 0, -1, 1, -2, 2, ....

float – real number (4 bytes)

 0.5, 3.2, 4.0, -5.122323, ...

double – double precision real number (8 bytes)

char float
int double
 Basic output: printf

printf
 Allows you to print on the screen
 To print some string using printf, we type:
printf("<any string>");
 To print a value of a variable using printf, we
use format specifiers:
printf("[format specifier]", variable);
printf Conversion Codes

%c – a character

%d – an integer, %u – an unsigned integer.

%f – a float

%e – a float in scientific representation

%g – whichever is better between %e and %f

%lf – a double

%% - the ‘%’ character
 Basic output: printf

Example:
char letter = 'a';
int number = 100;
float fnum = 13.09

printf("This is the letter %c",

letter);
printf("The number = %d", number);
printf("This is a floating point
number %f", fnum);
printf("%c %d %f", letter, number,
fnum);
 Basic input: scanf

scanf
 Allows you to get input from the keyboard

 Format:

scanf( "<formatSpecifier>", &variableName )

 Basic input: scanf

Examples:

int number;
char letter;

printf("Enter a number:");
scanf("%d", &number);
printf("Enter a character:");
scanf("%c", &letter);
 scanf Conversion Codes

%c – a character

%d – an integer, %u – an unsigned
integer.

%f – a float

%e – a float in different representation

%lf – a double
Exercise 2

Write a program that asks the user to
input his/her name, age, address,
telephone number and desired grade.
Afterwards print all the information
provided by the user.
Signed vs. Unsigned

integer types can be signed or unsigned
unsigned int ui;
unsigned char uc;

char
 signed: -128 to +127
 unsigned: 0 to +255

int
 signed: −2,147,483,648 to +2,147,483,647
 unsigned: 0 to +4,294,967,295
The unsigned qualifier

Normally, the last bit of a variable serves as
a sign bit. value
sign (+/-)

We can use all the bits to represent the

value by declaring a variable as unsigned.

To declare a variable as unsigned we add
the ‘unsigned’ keyword before its type.
 unsigned int;
 unsigned char;
Unsigned Range

char (256 different values)
 signed -127..+128
 unsigned 0..+255

int (4294967296 different values)
 signed -2147483648.. +2147483647
 unsigned 0.. +4294967295
Unsigned - output

When using printf We use %d for signed
variables and %u for unsigned ones
void main()
{
unsigned char u = 200;
char s;

printf("%d\n", u); 200

printf("%u\n", u);

s = u;
-56
printf("%d\n", s);
printf("%u\n", s); 4294967240
}
Overflow

Happens when a variable gets assigned a
value that is outside of its range

This is equivalent to saying that the
number of bits required to encode the
value exceeds the number of bits in the
variable

The value of the variable will usually be
corrupted
 Overflow Example
#include <stdio.h>

void main()
{
int iA = 1000,
iB = 1000000,
iC = 3000000,
iD = 5000000;
printf ("%d * %d = %d\n", iA, iB, iA*iB); 1000000000
printf ("%d * %d = %d\n", iA, iC, iA*iC); -1294967296
printf ("%d * %d = %u\n", iA, iC, iA*iC); 3000000000
printf ("%d * %d = %u\n", iA, iD, iA*iD); 705032704
}
 Casting

Sometimes it is desirable for a variable of one
type to be considered as belonging to another
in an operation

We say the variable is cast to the new type.

The casting operator is of the form: (type)

For example, (float)i casts the variable i
to a float.
IO functions from <stdio.h>
 printf - prints formatted output to stdout
 scanf - reads formatted input from stdin

 puts - prints a string to stdout

 gets - reads a string from stdin

 putc - prints a character to stdout

 getc, getchar - reads a character from stdin

 Operators

Types of operators in C:
 Arithmetic Operators
 Increment and Decrement Operators
 Relational Operators
 Logical Operators
 Modulo Operator
 Assignment Operator
 Shortcut Operators
 Arithmetic Operators
Arithmetic Function Examples
Operator
+ Used for Addition 5 + 2 is 7 (int)
5.0 + 2.0 is 7.0
(float)
- Used for Subtraction 5 – 2 is 3
5.0 – 2.0 is 3.0
* Used for Multiplication 5 * 2 is 10
5.0 * 2.0 is 10.0
/ Used for Division 5.0 / 2.0 is 2.5
(float)
5 / 2 is 2 (int)
 Increment and Decrement
Operators

Operator Function Examples

++ Increment operator int x = 10;
adds 1 to its x++; /*equal to 11*/
operand
-- Decrement operator int x = 10;
subtracts 1 to its x--; /*equal to 9*/
operand
 Increment and Decrement
Operators

++ and -- may be used either as prefix

operators (before the variable) or as
postfix operators (after the variable).
 Increment and Decrement
Operators

Example:
int num1 = 5;
int num2 = 0;
num1++; /*num1 == 6*/

--num2; /*num2 == -1*/

num2 = num1++; /*num2 is assigned value 6

*and num1 incremented*/
num2 = ++num1; /*num1 incremented and
*num2 is assigned value of ? */
 Exercise 3

Write a program in C that asks the user to input

the radius of a circle in centimeters (or portions
of centimeters), and then output the area and the
circumference of the circle to the screen. The
formula for the area is A = πr² and the formula
for the circumference is C = 2πr, where r is the
radius and π can be approximated to be 3.1416.
Exercise 4

Write a program in C that asks the user to

input two integers, one at a time, and
then outputs the sum and product to the
screen.
 Relational Operators

The result of a statement using relational
operators could either be 0 (false) and non-
zero values (true).
Relational Operator Function
< less than
> greater than
<= less than or equal to
>= greater than or equal to
== equal to
!= not equal to
 Relational Operators

Examples:
char ch1 = 'c';
int number1 = 10;
int number2 = 3;

ch1 == 'f' /*false*/

7 != number1 /*true*/
number2 > number1 /*false*/
number2 < number1 /*true*/
 Logical Operators

The result of a statement using logical

operators could either be 0 (false) and
non-zero values (true).

Logical operators
 Logical AND &&
 Logical OR ||
 Logical NOT !
 Logical XOR ^
 Logical Operators

Logical AND

Form: op1 && op2
op1 op2 result
nonzero nonzero nonzero
nonzero 0 0
0 nonzero 0
0 0 0
 Logical Operators

Logical OR

Form: op1 || op2
op1 op2 result
nonzero nonzero nonzero
nonzero 0 nonzero
0 nonzero nonzero
0 0 0
 Logical Operators

Logical NOT

Form: !op1

op1 result
nonzero 0
0 nonzero
 Logical Operators

Logical XOR

Form: op1 ^ op2
op1 op2 result
nonzero nonzero 0
nonzero 0 nonzero
0 nonzero nonzero
0 0 0
 Logical Operators

Examples:

int B1 = 1; /*true*/
int B2 = 0; /*false*/

B1 && B2; /*false*/

B1 || B2; /*true*/
!B1; /*true*/
B1 ^ B2 ; /*true*/
Modulo Operator (%)

C allows us to perform modulo operations

using the % symbol.

This means that if, for example, x and y are
two integer variables, the operation x % y will
return the remainder of the operation (dividing
the first operand by the second).

Examples:
10% 3 (this is equal to 1)
2 % 3 (this is equal to 2)
 Assignment Operator

An assignment Operator stores a
value or a computational result in a
variable. It is used to perform most
arithmetic operations in a program.

The syntax is:

<variable> = <expression>;
 Shortcut Operators

Any statement of the form:

<variable> = <variable> <operator>
<expression>;

where operator is one of the binary

operators
+ - * / % can be written in the form:
<variable> <operator> =<expression>;
 Shortcut Operators

Examples:
a = a + b can be written as a += b
c = c – 4 can be written as c -= 4
d = d * 5 can be written as d *= 5
e = e / 3 can be written as e /= 3
f = f % 2 can be written as f %= 2
 Operator Precedence
! (right-associative)
* / % (left-associative)
+ - (left-associative)
< <= > >= (left-associative)
== != (left-associative)
^ (left-associative)
&& (left-associative)
|| (left-associative)
= += -= *= /= %= (right-associative)
 Lesson Review

Precompiler directives or preprocessors are
statements in C that are processed before
compilation.

A library is a collection of useful functions and
symbols that may be accessed by a program

Declarations:Type declarations,
Variable/constant declarations,
Function/procedure declarations and Main
function declarations
 Lesson Review

C Statements are lines of code ending with a
semicolon (;).

Blocks are groups of statements enclosed in curly
braces {}.

C has at least 3 basic data types: Character (char),
Integer (int) and Floating point (float).

You can define your own data types by using
typedef. Type declaration using basic data types
has the following syntax:
typedef <data_type> <type_name>;
 Lesson Review

You can declare your own constants in C by using
const or #define. The syntax for const is:
const <data_type> <constant_name> =
<value>;

The syntax for #define is:
#define <constant_name> [value]

A variable in C is declared using the following
syntax:
<data_type> <variable_name> [=
<initial value>];
 Lesson Review

We use printf function to print to the screen
and scanf to get input from the keyboard.

The types of operators in C are: Arithmetic
Operators, Increment and Decrement
Operators, Relational Operators, Logical
Operators, Modulo Operator, Assignment
Operator and Shortcut Operators. They
follow a certain precedence.
 Exercise 5

Write a program that receives three

integers as input and outputs the numbers
in increasing order.
Control Structures

Lesson 4
Control Structures

Kinds of Control Structures
 Sequence Control Structures
 Selection Control Structures

if

if-else

switch
 Repetition Control Structures

while

do-while

for
 Sequential Program

statement1
int main() {
statement1;
statement2;
statement2
….
statementN;
}
statementN
if Statement

used to conditionally execute a statement or block of statement.

if (expression)
statement;
 True or False

In C, every expression has a numeric value

An expression is ‘true’ when its value is non-
zero

it is false it evaluates to zero.

Therefore, in the following –

if (expression)
statement

statement is executed if expression evaluates to

non-zero.
 if-else Statement

if (expression)
statement1;
else
statement2;

if expression is false, statement2 is executed

both statements can be (and very often are) replaced by
blocks of statements (“compound statements”)

The else portion is optional.
 Multiple if-else constructs

Multiple if-else constructs can also be used to choose between three of
more options.

TRUE
if (expression1) expression1 statement1

statement1; FALSE
else if (expression2) TRUE
expression2 statement2
statement2;
else FALSE

statement3; statement3

rest of program
 The conditional or ternary
operator: ‘?: ‘

The ?: operator is a more efficient form for expressing simple if
statements.

It has the following form:

<expression1>? <expression2>: <expression3>

It simply states:
if (<expression1>)
<expression2>;
else
<expression3>;
 The conditional or ternary
operator: ‘?: ‘

Example:
 Suppose we want to assign the maximum of a and
b to z. Using the ? operator, we have the following
statement:
z = (a > b) ? a : b;

which is the same as:

if (a > b)
z = a;
else
z = b;
 switch Statement

A multi-way conditional statement
 similar to the if … else if … else …

 allows the selection of an arbitrary number of choices

based on an integer value
switch (<expression>)
{
case <const_expr_1> : <statements>
case <const_expr_2> : <statements>
….
….
case <const_expr_n> : <statements>
default : <statements>
}
 switch Statement

expression must have an integer value (char, int)

when the switch statement is executed:
 the expression is evaluated

 if a case matches the value of the expression, the

program jumps to the first statement after that
case label
 otherwise, the default case is selected

 the default is optional

 while loop

The while loop has the following syntax:

while (<boolean expression>)
<statement>

 where,

The boolean_expression in the syntax can be any
expression that evaluates to TRUE or FALSE only.

The statement can be either a simple statement or
a compound statement.
 while loop

FALSE
expression

 The statement is executed as TRUE

long as condition is true.
statement/s
 The loop terminates when the
condition is no longer true.
rest of program
 while loop

Hereis a simple example of the use of the

while loop:
i=1
while (i<=5) {
printf("%d",i);
i++;
}
 while loop

There
are some things you have to
remember when using the while loop.
Firstand foremost is that the while loop
must terminate eventually. This means that
you have to make sure that the boolean
expression must evaluate to FALSE at some
foreseeable point. Loops that do not
terminate are called infinite loops.
 do-while loop
statement/s

TRUE
do {
statement(s); condition

} while ( condition );
FALSE

rest of program
 Similar to while loops
Except the condition is evaluated after the loop body

The loop body is always executed at least once, even if the

expression is never true
 do-while loop

Example:

i=1;
do {
printf("%d", i);
i++;
} while (i<=5);
 for loop

initialization
for ( <initialization>; <condition>;<increment> ) {
statement(s);
} condition

statement(s)

increment

rest of program
 break and continue

Cprovides two commands to control how

we loop:
 break – to exit from a loop or a switch
 continue – skip an iteration of the loop
End