Computer -- Hardware
Key board
Mouse
Input Devices
Input
Storage
Area
Program Storage Area
Output
Storage
Area
Working Storage Area
Primary or Main Memory (RAM)
Register 1
Register 2
……
……
Register N
Arithmetic
and
Logic Unit
Micro Processor
Secondary Storage Devices
Monitor
Printer
Output Devices
Algorithm: Step by step procedure of solving a particular problem.
Pseudo code: Artificial informal language used to develop algorithms.
Flow chart: Graphical representation of an algorithm.
Algorithm to find whether a number even or odd:
Step1: Begin
Step1: START
Step2: Take a number
Step2: Read num
Step3: if the number is divisible by2 then
Step3: if(num%2=0) then
print that number is even
print num is even
otherwise print that number is odd
otherwise
print num is odd
Step4: End
Step4: STOP
(Algorithm in natural language)
(Algorithm by using pseudo code)
#include<stdio.h>
#include<conio.h>
main()
{
int num;
printf(“Enter any number”);
scanf(“%d”,&num);
if(num%2==0)
printf(“%d is even”,num);
else
printf(%d is odd”,num);
}
(Program in C language)
start
Flow chart:
read num
Yes
If
num%2=0
No
print num
is odd
print num
is even
stop
Flow chart symbols
Oval
Terminal
Parallegram
Input/output
Rectangle
Process
Document
Hard copy
Diamond
Decision
Circle
Connector
Double sided Rectangle
Sub program
Hexagon
Iteration
Trapezoid
Manual Operation
Cylinder
Magnetic Disk Storage
Machine Language – Assembly Language – High-Level Language
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1
2
3
4
5
6
7
8
9
1
0
00000000 00000100 0000000000000000
01011110 00001100 11000010 0000000000000010
11101111 00010110 0000000000000101
11101111 10111110 0000000000001011
11111000 10101101 11011111 0000000000010010
01100010 11011111 0000000000010101
11101111 00000010 11111011 0000000000010111
11110100 10101101 11011111 0000000000011110
00000011 10100010 11011111 0000000000100001
11101111 00000010 11011111 0000000000100100
01111110 11110100 10101101
11111000 10101110 11000101 0000000000101011
00000110 10100010 11111011 0000000000110001
11101111 00000010 11111011 0000000000110100
01010000 11010100 0000000000111011
00000100 0000000000111101
#include<stdio.h>
int main(void)
{
int n1, n2,product;
printf(“Enter two numbers : “);
scanf(“%d %d”,&n1,&n2);
product = n1 * n2;
printf(“%d”,product);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
entry
main,^m<r2>
sub12 #12,sp
jsb
C$MAIN_ARGS
moveb $CHAR_STRING_CON
pusha1
pusha1
calls
pusha1
pusha1
calls
mull3
pusha
calls
clrl
ret
-8(fp)
(r2)
#2,SCANF
-12(fp)
3(r2)
#2,SCANF
-8(fp),-12(fp),6(fp)
#2,PRINTF
r0
The only language the computer can understand is machine
language (binary language).
A high level language is an English like language where one
instruction typically translates into a series of machinelanguage instructions.
A low level language corresponds closely to machine code
so that a single low-level language instruction translates to a
single machine language instruction.
Structure of C program
/*Program to find
area and perimeter of Circle */
#include<stdio.h>
#define PI 3.1415
float radius;
float area();
float perimeter();
int main()
{
float a, p;
printf(“Enter radius : “);
scanf(“%f”,&radius);
a = area();
p = perimeter();
printf(“Area of Circle : %f”,a);
printf(“Perimeter : %f”,p);
}
float area()
{
return (PI * radius * radius);
}
float perimeter()
{
return (2 * PI * radius);
}
Documentation Section
Linkage Section
Definition Section
Global Declaration Section
Main Function Section
Local Declaration Part
Executable Code Part
Sub Program Section
Function1()
Function2()
……………
FunctionN()
Program Development Steps
1)Statement of Problem
a) Working with existing system and using proper
questionnaire, the problem should be explained
clearly.
b) What inputs are available, outputs are required
and what is needed for creating workable solution
should be understood clearly.
2)Analysis
a) The method of solutions to solve the problem can
be identified.
b) We also judge that which method gives best
results among different methods of solution.
3)Designing
a) Algorithms and flow charts will be prepared.
b) Keep focus on data, architecture, user interfaces
and program components.
4)Implementation
The algorithms and flow charts developed in the
previous steps are converted into actual programs in
the high level languages like C.
4.a)Compilation
Translate the program into machine code. This
process is called as Compilation. Syntactic errors are
found quickly at the time of compiling the program.
These errors occur due to the usage of wrong syntaxes
for the statements.
Eg: x=a*y+b
There is a syntax error in this statement, since, each
and every statement in C language ends with a
semicolon (;).
4.b)Execution
The next step is Program execution. In this phase, we
may encounter two types of errors.
Runtime Errors: these errors occur during the
execution of the program and terminates the program
abnormally.
Logical Errors: these errors occur due to incorrect
usage of the instructions in the program. These errors
are neither detected during compilation or execution
nor cause any stoppage to the program execution but
produces incorrect ouz
Executing a C program
Text
Editor
#include<stdio.h>
int main()
{
…….
prog1.c
compiles
C-compiler
Yes
Syntax
Errors?
010110 100
…………….
01011 101
No
Object machine code
Linker
00101010
………….
01010101
prog1.obj
adds
Executable
machine code
machine code of
library file
prog1.exe
Executes
C-Runtime
Feeds
Input
Runtime
or Logic
Errors ?
Output
Yes
Translators are system software
used to convert high-level
language program into
machine-language code.
Compiler : Coverts the entire
source program at a time
into object code file, and
saves it in secondary storage
permanently. The same
object machine code file will
be executed several times,
whenever needed.
Interpreter : Each statement of
source program is translated
into machine code and
executed immediately.
Translation and execution of
each and every statement is
repeated till the end of the
program. No object code is
saved. Translation is
repeated for every execution
of the source program.
Character Set of C-Language
Alphabets : A-Z and a-z
Digits : 0-9
Special Symbols : ~ ! @ # $ % ^ & ( ) _ - + = | \ { } [ ] : ; “ ‘
<>,.?/
White Spaces : space , Horizontal tab, Vertical tab, New Line
Form Feed.
C-Language Keywords(C99)
auto
break
case
char
const
continue
default
do
_Bool
inline
double
else
enum
extern
float
for
goto
if
_Imaginary
int
long
register
return
short
signed
sizeof
static
restrict
struct
switch
typedef
union
unsigned
void
volatile
while
_Complex
C-Tokens
Tokens : The smallest individual units of a C- program are called Tokens.
Key words, Identifiers, Constants, Operators, Delimiters.
Key words : have a predefined meaning and these meanings cannot be
changed. All keywords must be written in small letters (except additional
c99 keywords).
Identifiers : names of variables, functions, structures, unions, macros, labels,
arrays etc.,
Rules for define identifiers :
a) First character must be alphabetic character or under score
b) Second character onwards alphabetic character of digit or under
score.
c) First 63 characters of an identifier are significant.
d) Cannot duplicate a key word.
e) May not have a space or any other special symbol except under
score.
f) C – language is Case-sensitive.
C-Tokens
Constants : fixed values that do not change during execution of a program.
Boolean constants : 0 ( false) and 1 (true)
Character constants :
only one character enclosed between two single quotes
( except escape characters ).
wide character type - wchar_t - for Unicode characters.
Integer constants : +123, -3454 , 0235 (octal value),
0x43d98 ( hexa - decimal value)
54764U, 124356578L, 124567856UL
Float constants : 0.2 , 876.345, .345623 , 23.4E+8, 47.45e+6
String Constants : “Hello world” , “Have a nice day!”
Complex Constants : real part + imaginary part * I ex : 12.3 + 3.45 * I
Operators : a symbol, which indicates an operation to be performed.
Operators are used to manipulate data in program.
Delimiters : Language Pattern of c-language uses special kind of symbols
: (colon, used for labels) ; (semicolon terminates statement ) ( ) parameter list
[ ] ( array declaration and subscript ), { } ( block statement )
# ( hash for preprocessor directive ) , (comma variable separator )
Data Types ( pre defined )
Type
Typical Size in Bits
char
8
unsigned char
8
signed char
8
int
16 or 32
unsigned int
16 or 32
signed int
16 or 32
short int
16
unsigned short int
16
signed short int
16
long int
32
long long int
64
signed long int
32
unsigned long int
32
unsigned long long int
64
float
32
double
64
long double
80
void
--
Minimal Range
–127 to 127
0 to 255
–127 to 127
–32,767 to 32,767
0 to 65,535
Same as int
–32,767 to 32,767
0 to 65,535
Same as short int
–2,147,483,647 to 2,147,483,647
–(263) to 263 – 1 (Added by C99)
Same as long int
0 to 4,294,967,295
264 – 1 (Added by C99)
3.4e-38 to 3.4e+38
1.7e-308 to 1.7e+308
3.4e-4932 to 1.1e+4932
data type that not return any value
Conversion Specifiers
Code
%a
%s
%c
%d
%f
%e
%g
%u
%o
%x
%i
%p
%n
%hd
%ld
%lf
%%
Format
Hexa decimal output in the form of 0xh.hhhhp+d(C99 only)
String of characters (until null zero is reached )
Character
Decimal integer
Floating-point numbers
Exponential notation floating-point numbers
Use the shorter of %f or %e
Unsigned integer
Octal integer
Hexadecimal integer
Signed decimal integer
Display a pointer
The associated argument must be a pointer to integer, This sepecifier causes
the number of characters written in to be stored in that integer.
short integer
long integer
long double
Prints a percent sign (%)
Back Slash ( Escape Sequence) Characters
Code
\b
\f
\n
\r
\t
\"
\'
\\
\v
\a
\?
\N
\xN
Meaning
Backspace
Form feed
New line
Carriage return
Horizontal tab
Double quote
Single quote
Backslash
Vertical tab
Alert
Question mark
Octal constant (N is an octal constant)
Hexadecimal constant (N is a hexadecimal constant)
Increment and Decrement Operators
prefix increment (++a)
postfix increment (a++)
Executes all Prefix Operations
prefix decrement(- -a)
postfix decrement (a- -)
Before evaluation of expression
Evaluation of expression
Executes all Postfix Operations
/* prefix operators */
#include<stdio.h>
int main() {
int a = 7, b = 12, c;
c = b * (++a) + 5 * (++a);
printf(“ a = %d”, a);
printf(“\n b = %d”,b);
printf(“\n c = %d”,c);
}
Output:
a=9
b = 12
c = 153 ( 12 * 9 + 5 * 9)
After evaluation of expression
and before leaving the statement
/* prefix and postfix operators */
#include<stdio.h>
int main() {
int a = 7, b = 12, c;
c = b * (a++) + 5 * (++a);
printf(“ a = %d”, a);
printf(“\n b = %d”,b);
printf(“\n c = %d”,c);
}
Output:
a=9
b = 12
c = 136 ( 12 * 8 + 5 * 8)
/* postfix operators */
#include<stdio.h>
int main() {
int a = 7, b = 12, c;
c = b * (a++) + 5 * (a++);
printf(“ a = %d”, a);
printf(“\n b = %d”,b);
printf(“\n c = %d”,c);
}
Output:
a=9
b = 12
c = 119 ( 12 * 7 + 5 * 7)
Bitwise Logical Operators
& -- Bitwise AND
A
B
A&B
A|B
A^B
~A
| -- Bitwise OR
1
1
1
1
0
0
1
0
0
1
1
0
^ -- Bitwise XOR
0
1
0
1
1
1
~ -- Bitwise NOT
0
0
0
0
0
1
Bitwise AND
Bitwise OR
A (42) : 00000000 00101010
B (15) : 00000000 00001111
----------------------------------& (10) : 00000000 00001010
-----------------------------------
A (42) : 00000000 00101010
B (15) : 00000000 00001111
----------------------------------| (47) : 00000000 00101111
-----------------------------------
Bitwise XOR
Bitwise NOT
A (42) : 00000000 00101010
B (15) : 00000000 00001111
----------------------------------& (37) : 00000000 00100101
-----------------------------------
A (42) : 00000000 00101010
----------------------------------~ (-43) : 11111111 11010101
-----------------------------------
BITWISE SHIFT OPERATORS
Bitwise Left Shift ( << )
Bitwise Right Shift ( >> )
(positive values)
A (43) : 00000000 00101011
----------------------------------A >> 2 : 00000000 00001010
-----------------------------------
Bitwise Right Shift ( >> )
(negetive values)
A (43) : 00000000 00101011
A (-44) : 11111111 11010100
--------------------------------------------------------------------A << 2 : 00000000 10101100
A >> 2 : 11111111 11110101
--------------------------------------------------------------------Note : Right shift operator fills the left vacant fields with ‘zeros’ for positive numbers,
with ‘ones’ for negative numbers.
Opposite
To
Gravity
TYPE CONVERSION
1.bool
(forcible)
.
.
.
(natural)
Gravity
Explicit Type Conversion
(casting)
2.char
(forcible)
3.short int
4.int
5.long int
6.long long int
.
.
.
7.float
8.double
9.long double
(automatic)
Implicit Type Conversion
(automatic)
Precedence and Associativity of Operators
Precdence Group
(Highest to Lowest )
(param) subscript etc.,
Unary operators
Multiplicative
Additive
Bitwise shift
Relational
Equality
Bitwise AND
Bitwise exclusive OR
Bitwise OR
Logical AND
Logical OR
Conditional
Assignment
Comma
Operators
Associativity
( ) [ ] –>.
- + ! ~ ++ – – (type) * & sizeof
*/%
+–
<< >>
< <= > >=
= = !=
&
^
|
&&
||
?:
= += –= *= /= %= &= ^=
|= <<= >>=
,
LR
RL
LR
LR
LR
LR
LR
LR
LR
LR
LR
LR
RL
RL
LR
simple if:
Test
Expression
?
False
Entry
if-else:
Entry
True
True Statement-block
True
True-block
Statements
False
Test
Expression
?
False-block
Statements
Next statement
Next statement
/* check a citizen is eligible for voting */
#include<stdio.h>
int main()
{
int age;
printf(“Enter the age : ”);
scanf(“%d”,&age);
if(age >= 18)
printf(“Eligible for voting…”);
getch();
}
/* print a number is even or odd */
#include<stdio.h>
int main()
{
int number;
printf(“Enter a number : “);
scanf(“%d”, &number);
if((number %2) == 0)
printf(“%d is even number.”,number);
else
printf(“%d is odd number.”,number);
}
nested if…else:
Entry
False
Test
condition1
?
False
Statement-3
Statement-2
Next statement
/* check whether a year is leap year or not */
#include<stdio.h>
int main() {
int year;
printf("Enter the year ?");
True
scanf("%d",&year);
if((year %100) == 0)
{
Test
True
if((year % 400) == 0)
condition2
printf("%d is leap year.",year);
?
else
printf("%d is not leap year.",year);
Statement-1
} else {
if((year % 4) == 0)
printf("%d is leap year.",year);
else
printf("%d is not leap year.",year);
}
getch();
}
if…else…if :
Entry
Test
condition1
?
True
Statement-1
False
Test
condition2
?
True
Statement-2
False
Test
conditionN
?
True
Statement-N
Next statement
/* program to print the grade of student */
#include<stdio.h>
int main() {
int marks;
printf("Enter marks ? ");
scanf("%d", &marks);
if(marks >= 75)
printf("Distinction");
else if(marks >= 60)
printf("First class");
else if(marks >= 50)
printf("Second class");
else if(marks >= 35)
printf("Third class");
else
printf("Failed");
}
switch statement :
Entry
switch
expression
?
value1
value2
valueN
……...
associate
statement
associate
statement
associate
statement
Exit
Next statement
/* program to simulate a simple calculator */
#include<stdio.h>
int main() {
float a,b;
char opr;
printf("Enter number1 operator number2 : ");
scanf("%f %c %f",&a,&opr,&b);
switch(opr)
default
{
case '+':
printf("Sum : %f",(a + b));
associate
break;
statement
case '-':
printf("Difference : %f",(a - b));
break;
case '*':
printf("Product : %f",(a * b));
break;
case '/':
printf("Quotient : %f",(a / b));
break;
default:
printf("Invalid Operation!");
}
}
Loop Statements
while – (Entry controlled )
Entry
Test
Condition
?
true
do-while – (Exit controlled )
Entry
False
Body of The loop
Following Statement
/* sum of 1 to 10 numbers */
#include<stdio.h>
int main() {
int i = 1,sum = 0;
while(i<=10){
sum = sum + i;
i = i + 1;
}
printf(“Total : %d “,sum);
}
Body of The loop
Test
Condition
?
True
False
Following Statement
/* average of 5 numbers */
#include<stdio.h>
int main() {
int count = 1;
float x, sum = 0;
do {
printf(“x = “);
scanf(“%f”,&x);
sum += x;
++ count;
} while(count <= 5);
printf(“Average = %f “, (sum/5))
}
for -- Statement
Entry
Initialization Statement
Increment Statement
False
Following Statement
Test
Condition
?
True
Body of The loop
/* check whether a number is prime or not */
#include<stdio.h>
int main() {
int n,i,factors = 0;
printf("Enter a number : ");
scanf("%d",&n);
for(i = 1; i <= n; i++) {
if((n % i)==0) ++factors;
}
if (factors == 2)
printf("%d is prime number.",n);
else
printf("%d is not prime number.",n);
}
Important Functions in math.h
abs(x)
ceil(x)
floor(x)
log(x)
pow(x,y)
sqrt(x)
exp(x)
sin(x)
cos(x)
tan(x)
fmod(x,y)
hypot(x,y)
log10(x)
absolute value of integer x
rounds up and returns the smallest integer greater than or
equal to x
rounds down and returns the largest integer less than or equal
to x
returns natural logarithm
returns the value of xy
returns square root of x
returns natural anti logarithm
returns sine value where x in radians
returns cosine value where x in radians
returns tangent values where x in radians
calculate x modulo y, where x and y are double
calculate hypotenuse of right angle where x,y are sides.
returns logarithm base 10