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
