Advanced C - Part 1

Team Emertxe
C
Come let's see how deep it is!!

Advanced C
Course: Education goals and objectives
●
Expectations out of this module
●
●
At the end of the course the student will learn
●
Collaboration Policy
●
Assignment Policy
●
Course flow

Advanced C ontents
int main(void) {
Problem Solving
Introduction to C Programming
Basic Refreshers
Functions Part1
Pointers Part1
Standard Input and Output
Strings
Storage Classes
Pointers Part2
Functions Part2
Preprocessing
User Defined Datatypes
File Input and Output
Miscellaneous
}

Advanced C
Have you ever pondered how
- powerful it is?
- efficient it is?
- flexible it is?
- deep you can explore your system?
if [ NO ]
Wait!! get some concepts right before you dive into it
else
You shouldn't be here!!

Advanced C
Introduction - Where is it used?
●
System Software Development
●
Embedded Software Development
●
OS Kernel Development
●
Firmware, Middle-ware and Driver Development
●
File System Development
And many more!!

Advanced C
Introduction - Language – What?
●
A stylized communication technique
●
Language has collection of words called
“Vocabulary”
– Rich vocabulary helps us to be more expressive
●
Language has finite rules called “Grammar”
– Grammar helps us to form infinite number of sentences
●
The components of grammar :
– The syntax governs the structure of sentences
– The semantics governs the meanings of words and
sentences

Advanced C
Introduction - Language – What?
●
A stylized communication technique
●
It has set of words called “keywords”
●
Finite rules (Grammar) to form sentences (often called
expressions)
– Expressions govern the behavior of machine (often a
computer)
●
Like natural languages, programming languages too
have :
– Syntactic rules (to form expressions)
– Semantic rules (to govern meaning of expressions)

Advanced C
Introduction - Brief History
●
Prior to C, most of the computer languages (such as Algol)
were academic oriented, unrealistic and were generally
defined by committees.
●
Since such languages were designed having application
domain in mind, they could not take the advantages of
the underlying hardware and if done, were not portable
or efficient under other systems.
●
It was thought that a high-level language could never
achieve the efficiency of assembly language
Portable, efficient and easy to use language was a dream.

Advanced C
Introduction - Brief History
●
It was a revolutionary language and shook the computer
world with its might. With just 32 keywords, C
established itself in a very wide base of applications.
●
It has lineage starting from CPL, (Combined Programming
Language) a never implemented language
●
Martin Richards implemented BCPL as a modified version
of CPL. Ken Thompson further refined BCPL to a language
named as B
●
Later Dennis M. Ritchie added types to B and created a
language, what we have as C, for rewriting the UNIX
operating system

Advanced C
Introduction - Important Characteristics
●
Considered as a middle level language
●
Can be considered as a pragmatic language
●
It is indented to be used by advanced programmers, for
serious use, and not for novices and thus qualify less as
an academic language for learning
●
Gives importance to compact code
●
It is widely available in various platforms from
mainframes to palmtops and is known for its wide
availability

Advanced C
Introduction - Important Characteristics
●
It is a general-purpose language, even though it is applied
and used effectively in various specific domains
●
It is a free-formatted language (and not a strongly-typed
language)
●
Efficiency and portability are the important
considerations
●
Library facilities play an important role

Advanced C
Introduction - Standard
●
“The C programming language” book served as a
primary reference for C programmers and
implementers alike for nearly a decade
●
However it didn’t define C perfectly and there
were many ambiguous parts in the language
●
As far as the library was concerned, only the C
implementation in UNIX was close to the
’standard’
●
So many dialects existed for C and it was the time the language has
to be standardized and it was done in 1989 with ANSI C standard
●
Nearly after a decade another standard, C9X, for C is available that
provides many significant improvements over the previous 1989
ANSI C standard

Advanced C
Introduction - Keywords
●
In programming, a keyword is a word that is reserved by a
program because the word has a special meaning
●
Keywords can be commands or parameters
●
Every programming language has a set of keywords that
cannot be used as variable names
●
Keywords are sometimes called reserved names

Advanced C
Introduction - Keywords - Categories
Type Keyword
Data Types char
int
float
double
Modifiers signed
unsigned
short
long
Qualifiers const
volatile
Loops for
while
do
Jump goto
break
continue
Type Keyword
Decision if
else
switch
case
default
Storage Class auto
register
static
extern
Derived struct
union
User defined enum
typedef
Others void
return
sizeof

Advanced C
Introduction - Typical C Code Contents
Documentation
Preprocessor Statements
Global Declaration
The Main Code:
--------------------
Local Declarations
Program Statements
Function Calls
One or many Function(s):
---------------------------------
The function body
●
A typical code might contain the
blocks shown on left side
●
It is generally recommended to
practice writing codes with all
the blocks

Advanced C
Introduction - Anatomy of a Simple C Code
/* My first C code */
#include <stdio.h>
int main()
{
/* To display Hello world */
printf("Hello worldn");
return 0;
}
File Header
Preprocessor Directive
The start of program
Comment
Statement
Program Termination

Advanced C
Introduction - Compilation
●
Assuming your code is ready, use the following commands
to compile the code
●
On command prompt, type
$ gcc <file_name>.c
●
This will generate a executable named a.out
●
But it is recommended that you follow proper conversion
even while generating your code, so you could use
$ gcc <file_name>.c -o <file_name>
●
This will generate a executable named <file_name>

Advanced C
Introduction - Execution
●
To execute your code you shall try
$ ./a.out
●
If you have named you output file as your <file_name>
then
$ ./<file_name>
●
This should the expected result on your system

Advanced C
Problem Solving – What?
●
An approach which could be taken to reach to a solution
●
The approach could be ad hoc or generic with a proper
order
●
Sometimes it requires a creative and out of the box
thinking to reach to perfect solution

●
Introduction to SDLC
●
Polya’s Rules
●
Algorithm Design Methods
Advanced C
Problem Solving

Advanced C
Problem Solving - SDLC – A Quick Introduction
●
Never jump to implementation. Why?
– You might not have the clarity of the application
– You might have some loose ends in the requirements
– Complete picture of the application could be missing
and many more...

Advanced C
Requirement
Design
Code
Test
●
Understand the requirement properly
●
Consider all the possible cases like inputs
and outputs
●
Know the boundary conditions
●
Get it verified

Advanced C
Requirement
Design
Code
Test
●
Have a proper design plan
●
Use some algorithm for the requirement
●
Use paper and pen method
●
Use a flow chart if required
●
Make sure all the case are considered

Advanced C
Requirement
Design
Code
Test
●
Implement the code based on the derived
algorithm
●
Try to have modular structure where ever
possible
●
Practice neat implementation habits like
●
Indentation
●
Commenting
●
Good variable and function naming's
●
Neat file and function headers

Advanced C
Requirement
Design
Code
Test
●
Test the implementation thoroughly
●
Capture all possible cases like
●
Negative and Positive case
●
Have neat output presentation
●
Let the output be as per the user requirement

Advanced C
Problem Solving – How?
●
Polya's rule
– Understand the problem
– Devise a plan
– Carryout the Plan
– Look back

Advanced C
Problem Solving – Algorithm – What?
●
A procedure or formula for solving a problem
●
A sequence of unambiguous instructions for solving a
problem, i.e., for obtaining a required output for any
legitimate input in a finite amount of time.

Advanced C
Problem Solving – Algorithm – Need?
●
Algorithms is needed to generate correct output in finite
time in a given constrained environment
– Correctness of output
– Finite time
– Better Prediction

Advanced C
Problem Solving – Algorithm – How?
●
Natural Language
●
Pseudo Codes
●
Flowcharts etc.,

Advanced C
Problem Solving – Algorithm – Daily Life Example
●
Let's consider a problem of reaching this room
●
The different possible approach could be thought of
– Take a Walk
– Take a Bus
– Take a Car
– Let's Pool
●
Lets discuss the above approaches in bit detail

Advanced C
Algorithm – Reaching this Room – Take a Walk
The steps could be like
1.Start a 8 AM
2.Walk through street X for 500 Mts
3.Take a left on main road and walk for 2 KM
4.Take a left again and walk 200 Mts to reach

Advanced C
Algorithm – Reaching this Room – Take a Walk
●
Pros
– You might say walking is a good exercise :)
– Might have good time prediction
– Save some penny
●
Cons
●
Depends on where you stay (you would choose if
you stay closer)
●
Should start early
●
Would get tired
●
Freshness would have gone

Advanced C
Algorithm – Reaching this Room – Take a Bus
1.Start a 8 .30 AM
3.Take a left on main road and walk for 100 Mts to bus stop
4.Take Bus No 111 and get down at stop X and walk for 100
Mts
5.Take a left again and walk 200 Mts to reach

Advanced C
Algorithm – Reaching this Room – Take a Bus
●
Pros
– You might save some time
– Less tiredness comparatively
●
Cons
– Have to walk to the bus stop
– Have to wait for the right bus (No prediction of time)
– Might not be comfortable on rush hours

Advanced C
Algorithm – Reaching this Room – Take a Car
1.Start a 9 AM
2.Drive through street X for 500 Mts
3.Take a left on main road and drive 2 KM
4.Take a left again and drive 200 Mts to reach

Advanced C
Algorithm – Reaching this Room – Take a Car
●
Pros
– Proper control of time and most comfortable
– Less tiresome
●
Cons
– Could have issues on traffic congestions
– Will be costly

Advanced C
Algorithm – Reaching this Room – Let's Pool
1.Start a 8.45 AM
3.Reach the main road wait for you partner
4.Drive for 2 KM on the main road
5.Take a left again and drive 200 Mts to reach

Advanced C
Algorithm – Reaching this Room – Let's Pool
●
Pros
– You might save some time
– Less costly comparatively
●
Cons
– Have to wait for partner to reach
– Could have issues on traffic congestions

Advanced C
Algorithm – Daily Life Example - Conclusion
●
All the above solution eventually will lead you to this
room
●
Every approach some pros and cons
●
It would be our duty as a designer to take the best
approach for the given problem

Advanced C
Algorithm – A Computer Example1
●
Let's consider a problem of adding two numbers
●
The steps involved :
Start
Read the value of A and B
Add A and B and store in SUM
Display SUM
Stop
●
The above 5 steps would eventually will give us the
expected result

Advanced C
Algorithm – A Computer Example1 – Pseudo Code
●
●
The steps involved :
BEGIN
Read A, B
SUM = A + B
Print SUM
END
●
The above 5 steps would eventually will give us the
expected result

Advanced C
Algorithm – A Computer Example1 – A Flow Chart
●
Start
Read A and B
Add A and B
Print SUM
Stop

Advanced C
Algorithm – DIY – Pattern
●
Write an algorithm to print the below pattern
***********
* *
* *
* *
* *
* *
* *
* *
**********

Advanced C
Algorithm – DIY – Pattern
●
Write an algorithm to print number pyramid
1234554321
1234__4321
123____321
12______21
1________1

Advanced C
Algorithm – DIY
●
Finding largest of 2 numbers
●
Find the largest member of an array

Advanced C
Algorithm – Home Work
●
Count the number of vowels
●
Count the number of occurrence of each vowel
●
To find the sum of n – natural numbers
●
Convert a number from base 10 to base N

Advanced C
Number Systems
●
A number is generally
represented as
– Decimal
– Octal
– Hexadecimal
– Binary
Dec
0 0 0 0
Oct Hex Bin
0 0 0 0
10 8 16 2
Type
Base
0 0 0
0 0 0 00 0 0 11 1 1
0 0 0 00 0 1 02 2 2
0 0 0 00 0 1 13 3 3
0 0 0 00 1 0 04 4 4
0 0 0 00 1 0 15 5 5
0 0 0 00 1 1 06 6 6
0 0 0 00 1 1 17 7 7
0 0 0 01 0 0 08 10 8
0 0 0 01 0 0 19 11 9
0 0 0 01 0 1 010 12 A
0 0 0 01 0 1 111 13 B
0 0 0 01 1 0 012 14 C
0 0 0 01 1 0 113 15 D
0 0 0 01 1 1 014 16 E
0 0 0 01 1 1 115 17 F
Decimal
Type Range (8 Bits)
Octal
Hexadecimal
Binary 0b00000000 - 0b11111111
0 - 255
000 - 0377
0x00 - 0xFF

Advanced C
Number Systems – Decimal to Binary
● 12510 to Binary
1252
622 1
312 0
152 1
72 1
32 1
12 1
0 1
● So 12510 is 11111012
MSB
LSB

Advanced C
Number Systems – Decimal to Octal
● 21210 to Octal
2128
268 4
38 2
0 3
● So 21210 is 3248
MSB
LSB

Advanced C
Number Systems – Decimal to Hexadecimal
● 47210 to Hexadecimal
47216
2916 8
1 13
1
● So 47210 is 1D816
MSB
LSB
Dec
Representation Substitutes
Hex
4
4
5
5
6
6
7
7
8
8
9
9
10
A
11
B
12
C
13
D
14
E
15
F
0
0
1
1
2
2
3
3
16
0

Advanced C
Number Systems – Hexadecimal to Binary
● 1D816 to Binary
● So 1D816 is 0001110110002 which is nothing but 1110110002
1 D 8
1 D 8
0 0 0 01 0 0 00 0 0 01 1 0 10 0 0 00 0 0 1

Advanced C
Number Systems – Octal to Binary
● 3248 to Binary
● So 3248 is 0110101002 which is nothing but 110101002
3 2 4
3 2 4
0 0 01 0 00 0 00 1 00 0 00 1 1

Advanced C
Number Systems – Octal to Hexadecimal
● 3248 to Hexadecimal
● So 3248 is 0D416 which is nothing but D416
3 2 4
3 2 4
0 1 00 1 1 1 0 0
1 0 000 1 00 1 1
1 0 000 11 10000
0 D 4

Advanced C
Number Systems – Hexadecimal to Octal
● 1D816 to Octal
● So 1D816 is 07308 which is nothing but 7308
1 D 8
1 D 8
00 010 11 10 100
0 0 010 11 11000
0 7 3 0
0 0 010 11 11000

Advanced C
Number Systems – Binary to Decimal
● 1110110002 to Decimal
● So 1110110002 is 47210
1 0 0 01 1 0 11
3 2 1 07 6 5 48Bit Position
2
3
2
2
2
1
2
0
2
7
2
6
2
5
2
4
2
8
8 0 0 0128 64 0 16256 + + + + + + + +
472
=

Advanced C
Data Representation - Bit
●
Literally computer understand only two states HIGH and
LOW making it a binary system
●
These states are coded as 1 or 0 called binary digits
●
“Binary Digit” gave birth to the word “Bit”
●
Bit is known a basic unit of information in computer and
digital communication
0
Value No of Bits
0
1 1

Advanced C
Data Representation - Byte
●
A unit of digital information
●
Commonly consist of 8 bits
●
Considered smallest addressable unit of memory in
computer
0
Value No of Bits
0
1 0
0
0
0
0
0
0
0
0
0
0
0
0
0
1

Advanced C
Data Representation - Character
●
One byte represents one unique character like 'A', 'b', '1',
'$' ...
●
Its possible to have 256 different combinations of 0s and
1s to form a individual character
●
There are different types of character code
representation like
– ASCII American Standard Code for Information→
Interchange – 7 Bits (Extended - 8 Bits)
– EBCDIC Extended BCD Interchange Code – 8 Bits→
– Unicode Universal Code - 16 Bits and more→

Advanced C
Data Representation - Character
●
ASCII is the oldest representation
●
Please try the following on command prompt to know the
available codes
$ man ascii
●
Can be represented by char datatype
0
Value No of Bits
A
0
0
0
1
1
0
1
0
0
0
0
0
0
0
0
1

Advanced C
Data Representation - word
●
Amount of data that a machine can fetch and process at
one time
●
An integer number of bytes, for example, one, two, four,
or eight
●
General discussion on the bitness of the system is
references to the word size of a system, i.e., a 32 bit
chip has a 32 bit (4 Bytes) word size
0
Value No of Bits
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1

Advanced C
Integer Number - Positive
●
Integers are like whole numbers, but allow negative
numbers and no fraction
● An example of 1310 in 32 bit system would be
Position
Bit No of Bits
Value
31
0
30
0
29
0
28
0
27
0
26
0
25
0
24
0
23
0
22
0
21
0
20
0
19
0
18
0
17
0
16
0
15
0
14
0
13
0
12
0
11
0
10
0
9
0
8
0
7
0
6
0
5
0
4
0
3
1
2
1
1
0
0
1

Advanced C
Integer Number - Negative
Position
Bit No of Bits
Value
31
0
30
0
29
0
28
0
27
0
26
0
25
0
24
0
23
0
22
0
21
0
20
0
19
0
18
0
17
0
16
0
15
0
14
0
13
0
12
0
11
0
10
0
9
0
8
0
7
0
6
0
5
0
4
0
3
1
2
1
1
0
0
1
1's Compli 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0
Add 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
2's Compli 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1
●
Mathematically : -k 2≡
n
- k
●
Negative Integers represented with the 2's complement of
the positive number
● An example of -1310 in 32 bit system would be

Advanced C
Float Point Number
●
A formulaic representation which approximates a real
number
●
Computers are integer machines and are capable of
representing real numbers only by using complex codes
●
The most popular code for representing real numbers is
called the IEEE Floating-Point Standard
Sign Exponent Mantissa
Float (32 bits)
Single Precision
1 bit 8 bits 23 bits
Double (64 bits)
Double Precision
1 bit 11 bits 52 bits

Advanced C
Float Point Number – Conversion Procedure
●
STEP 1: Convert the absolute value of the number to binary, perhaps
with a fractional part after the binary point. This can be done by -
– Converting the integral part into binary format.
– Converting the fractional part into binary format.
The integral part is converted with the techniques examined
previously.
The fractional part can be converted by multiplying it with 2.
●
STEP 2: Normalize the number. Move the binary point so that it is
one bit from the left. Adjust the exponent of two so that the value
does not change.
Float : V = (-1)s * 2(E-127) * 1.F
Double : V = (-1)s * 2(E-1023) * 1.F

Advanced C
Float Point Number – Conversion - Example 1
0.5 × 2 1.0 1
Step 1:
Convert 0.5 to IEEE 32-bit floating point format
0.510 = 0.12
Step 2:
Normalize:
0.12 = 1.02 × 2-1
Mantissa is 00000000000000000000000
Exponent is -1 + 127 = 126 = 011111102
Sign bit is 0
Bit S
Value 0 0 1 1 1 1 1 1 0
Position 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Exponent Mantissa

Advanced C
8 / 2 4 0
4 / 2 2 0
2 / 2 1 0
1 1
Step 1:
Step 2:
Normalize:
1000.012 = 1.000012 × 23
Mantissa is 00001000000000000000000
Exponent is 3 + 127 = 130 = 1000 00102
Sign bit is 0
Bit S
Value 0 1 0 0 0 0 0 1 0
Position 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Exponent Mantissa
0.25 × 2 0.5 0
0.5 × 2 1.0 1
8.2510 = 1000.012
Integer Part to Binary:
Fractional Part to Binary:
Result:

Advanced C
0.625 × 2 1.25 1
0.25 × 2 0.5 0
0.5 × 2 1.0 1
Step 1:
0.62510 = 0.1012
Step 2:
Normalize:
0.1012 = 1.012 × 2-1
Mantissa is 01000000000000000000000
Exponent is -1 + 127 = 126 = 011111102
Sign bit is 0
Bit S
Value 0 0 1 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Position 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0
Exponent Mantissa

Advanced C
0.5625 × 2 1.125 1
0.125 × 2 0.25 0
0.25 × 2 0.5 0
0.5 × 2 1.0 1
Step 1:
Step 2:
Normalize:
1001101111001111.10012 =
1.00110111100111110012 × 2
15
Mantissa is 00110111100111110010000
Exponent is 15 + 127 = 142 = 100011102
Sign bit is 0
Bit S
Value 0 1 0 0 0 1 1 1 0 0 0 1 1 0 1 1 1 1 0 0 1 1 1 1 1 0 0 1 0 0 0
Position 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0
Exponent Mantissa
39887.562510 =
1001101111001111.10012

Advanced C
0.3125 × 2 0.625 0
0.625 × 2 1.25 1
0.25 × 2 0.5 0
0.5 × 2 1.0 1
Step 1:
Convert -13.3125 to IEEE 32-bit floating point format
13.312510 = 1101.01012
Step 2:
Normalize:
1101.01012 = 1.10101012 × 23
Mantissa is 10101010000000000000000
Exponent is 3 + 127 = 130 = 1000 00102
Sign bit is 1
Bit S
Value 1 1 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Position 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0
Exponent Mantissa

Advanced C
0.7 × 2 1.4 1
0.4 × 2 0.8 0
0.8 × 2 1.6 1
0.6 × 2 1.2 1
0.2 x 2 0.4 0
0.4 × 2 0.8 0
0.8 × 2 1.6 1
0.6 × 2 1.2 1
Step 1:
1.710 = 1.101100110011001100110012
Step 2:
Normalize:
1.101100110011001100110012 =
1.101100110011001100110012 × 2
0
Mantissa is 10110011001100110011001
Exponent is 0 + 127 = 127 = 011111112
Sign bit is 0
Bit S
Value 0 0 1 1 1 1 1 1 1 1 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0
Position 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
1
Exponent Mantissa

Advanced C
Data Types - Categories
Data
Types
Integral
Real
char
int
float
double

Advanced C
Data Types - Usage
Syntax
data_type name_of_the_variable;
Example
char option;
int age;
float height;

Advanced C
Data Types – Storage
char option;
int age;
float height;
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
Example

Advanced C
Data Types – Printing
#include <stdio.h>
int main()
{
char option;
int age;
float height;
printf(“The character is %cn”, option);
printf(“The integer is %dn”, age);
printf(“The float is %fn”, height);
return 0;
}
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
001_example.c

Advanced C
Data Types – Scaning
#include <stdio.h>
int main()
{
char option;
int age;
float height;
scanf(“%c”, &option);
printf(“The character is %cn”, option);
scanf(“%d”, &age);
printf(“The integer is %dn”, age);
scanf(“%f”, &height);
printf(“The float is %fn”, height);
return 0;
}
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
002_example.c

Advanced C
Data Types – Size
#include <stdio.h>
int main()
{
char option;
int age;
float height;
printf(“The size of char is %un”, sizeof(char));
printf(“The size of int is %un”, sizeof(int));
printf(“The float is %un”, sizeof(float));
return 0;
}
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
003_example.c

Advanced C
Data Types - Modifiers and Qualifiers
●
These are some keywords which is used to tune the
property of the data type like
– Its width
– Its sign
– Its storage location in memory
– Its access property
●
The K & R C book mentions only two types of qualifiers
(refer the next slide). The rest are sometimes
interchangably called as specifers and modifiers and
some people even call all as qualifiers!

Advanced C
Data Types - Modifiers and Qualifiers
Modifiers
Size
Signedness
short
signed
unsigned
long
T
T
T
T
Qualifiers
const
volatile
V
V V Variables
T Data Types
F FunctionsNote: Unsigned float in not supported

Advanced C
Data Types - Modifiers and Qualifiers - Usage
<modifier> <qualifier> <data_type> name_of_the_variable;
short int count1;
long int count2;
const int flag;
Syntax
Example

Advanced C
Data Types – Modifiers - Size
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
004_example.c
#include <stdio.h>
int main()
{
short int count1;
int long count2;
short count3;
printf(“short is %u bytesn”, sizeof(short int));
printf(“long int is %u bytesn”, sizeof(int long));
printf(“short is %u bytesn”, sizeof(short));
return 0;
}

Advanced C
Data Types – Modifiers - Sign
#include <stdio.h>
int main()
{
unsigned int count1;
signed int count2;
unsigned char count3;
signed char count4;
printf(“count1 is %u bytesn”, sizeof(unsigned int));
printf(“count2 is %u bytesn”, sizeof(signed int));
printf(“count3 is %u bytesn”, sizeof(unsigned char));
printf(“count3 is %u bytesn”, sizeof(signed char));
return 0;
}
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
005_example.c

Advanced C
Data Types – Modifiers – Sign and Size
#include <stdio.h>
int main()
{
unsigned short count1;
signed long count2;
short signed count3;
printf(“count1 is %u bytesn”, sizeof(count1));
return 0;
}
0000
0004
0008
1000
1004
1008
1012
1020
1016
●
●
●
006_example.c

Advanced C
Data Types – Modifiers – Sign and Size
007_example.c
#include <stdio.h>
int main()
{
unsigned int count1 = 10;
signed int count2 = -1;
if (count1 > count2)
{
printf(“Yesn”);
}
else
{
printf(“Non”);
}
return 0;
}

Advanced C
Data Types and Function - Storage Modifiers
Storage
Modifiers
auto
extern
register
inline
static
V
V
V
V
F
V Variables
T Data Types
F Functions
F
F

Advanced C
Code Statements - Simple
int main()
{
number = 5;
3; +5;
sum = number + 5;
4 + 5;
;
}
Assignment statement
Valid statement, But smart compilers
might remove it
Assignment statement. Result of the
number + 5 will be assigned to sum
Valid statement, But smart compilers
might remove it
This valid too!!

Advanced C
Code Statements - Compound
int main()
{
...
if (num1 > num2)
{
if (num1 > num3)
{
printf(“Hello”);
}
else
{
printf(“World”);
}
}
...
}
If conditional statement
Nested if statement

Advanced C
Conditional Constructs
Conditional
Constructs
Multi iteration
Single iteration
for
do while
while
if and its family
switch case

Advanced C
Conditional Constructs - if
#include <stdio.h>
int main()
{
int num = 2;
if (num < 5)
{
printf(“num < 5n”);
}
printf(“num is %dn”, num);
return 0;
}
Syntax
if (condition)
{
statement(s);
}
Flow
cond?
true
code
false
008_example.c

Advanced C
Conditional Constructs – if else
Syntax
if (condition)
{
statement(s);
}
else
{
statement(s);
}
Flow
cond?
true
code
false
code

Advanced C
Conditional Constructs – if else
#include <stdio.h>
int main()
{
int num = 10;
if (num < 5)
{
printf(“num is smaller than 5n”);
}
else
{
printf(“num is greater than 5n”);
}
return 0;
}
009_example.c

Advanced C
Conditional Constructs – if else if
Syntax
if (condition1)
{
statement(s);
}
else if (condition2)
{
statement(s);
}
else
{
statement(s);
}
Flow
cond1? code
true
false
cond2?
code
code
true
false

Advanced C
Conditional Constructs – if else if
#include <stdio.h>
int main()
{
int num = 10;
if (num < 5)
{
printf(“num is smaller than 5n”);
}
else if (num > 5)
{
printf(“num is greater than 5n”);
}
else
{
printf(“num is equal to 5n”);
}
return 0;
}
010_example.c

Advanced C
Conditional Constructs – Exercise
●
WAP to find the max of two numbers
●
WAP to print the grade for a given percentage
●
WAP to find the greatest of given 3 numbers
●
WAP to check whether character is
– Upper case
– Lower case
– Digit
– No of the above
●
WAP to find the middle number (by value) of given 3
numbers

Advanced C
Conditional Constructs – switch
Syntax
switch (expression)
{
case constant:
statement(s);
break;
case constant:
statement(s);
break;
case constant:
statement(s);
break;
default:
statement(s);
}
Flow
expr
code
true
false
case1? break
case2?
default
code break
code break
true
false

Advanced C
Conditional Constructs - switch
#include <stdio.h>
int main()
{
int option;
printf(“Enter the valuen”);
scanf(“%d”, &option);
switch (option)
{
case 10:
printf(“You entered 10n”);
break;
case 20:
printf(“You entered 20n”);
break;
default:
printf(“Try againn”);
}
return 0;
}
011_example.c

Advanced C
Conditional Constructs – switch - DIY
●
W.A.P to check whether character is
– Upper case
– Lower case
– Digit
– None of the above
●
W.A.P for simple calculator

Advanced C
Conditional Constructs – while
Syntax
while (condition)
{
statement(s);
}
Flow
false
true
cond?
code
#include <stdio.h>
int main()
{
int iter;
iter = 0;
while (iter < 5)
{
printf(“Looped %d timesn”, iter);
iter++;
}
return 0;
}
●
Controls the loop.
●
Evaluated before each
execution of loop body
012_example.c

Advanced C
Conditional Constructs – do while
Syntax
do
{
statement(s);
} while (condition);
Flow
false
true
cond?
code#include <stdio.h>
int main()
{
int iter;
iter = 0;
do
{
iter++;
} while (iter < 10);
return 0;
}
●
Controls the loop.
●
Evaluated after each
013_example.c

Advanced C
Conditional Constructs – for
Syntax
for (init; condition; post evaluation expr)
{
statement(s);
}
Flow
init
false
true
cond?
code
post eval
expr
#include <stdio.h>
int main()
{
int iter;
for (iter = 0; iter < 10; iter++)
{
}
return 0;
}
●
Controls the loop.
●
Evaluated before each
014_example.c

Advanced C
Conditional Constructs - Classwork
●
W.A.P to print the power of two series using for loop
– 21, 22, 23, 24, 25 ...
●
W.A.P to print the power of N series using Loops
– N1, N2, N3, N4, N5 ...
●
W.A.P to multiply 2 nos without multiplication operator
●
W.A.P to check whether a number is palindrome or not

Advanced C
Conditional Constructs – for – DIY
●
WAP to print line pattern
– Read total (n) number of pattern chars in a line (number
should be “odd”)
– Read number (m) of pattern char to be printed in the
middle of line (“odd” number)
– Print the line with two different pattern chars
– Example – Let's say two types of pattern chars '$' and '*' to
be printed in a line. Total number of chars to be printed in
a line are 9. Three '*' to be printed in middle of line.
●
Output ==> $$$* * *$$$

Advanced C
●
Based on previous example print following pyramid
*
* * *
* * * * *
* * * * * * *

Advanced C
●
Print rhombus using for loops
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*

Advanced C
Conditional Constructs – break
Syntax
do
{
conditional statement
break;
Flow
●
A break statement shall appear
only in “switch body” or “loop
body”
●
“break” is used to exit the loop,
the statements appearing after
break in the loop will be skipped
false
true
loop
cond?
code block
cond?
false
break?
true

Advanced C
Conditional Constructs – break
#include <stdio.h>
int main()
{
int iter;
{
if (iter == 5)
{
break;
}
printf(“%dn”, iter);
}
return 0;
}
015_example.c

Advanced C
Conditional Constructs – continue
Syntax
do
{
conditional statement
continue;
Flow
●
A continue statement causes a jump
to the loop-continuation portion,
that is, to the end of the loop body
●
The execution of code appearing
after the continue will be skipped
●
Can be used in any type of multi
iteration loop
false
true
loop
cond?
code block
cond?
false
continue?
true
code block

Advanced C
Conditional Constructs – continue
#include <stdio.h>
int main()
{
int iter;
{
if (iter == 5)
{
continue;
}
printf(“%dn”, iter);
}
return 0;
}
016_example.c

Advanced C
Conditional Constructs – goto
Syntax
goto label;
…
…
label:
…
●
A goto statement causes a
unconditional jump to a labeled
statement
●
Generally avoided in general
programming, since it sometimes
becomes tough to trace the flow
of the code

Advanced C
Operators
●
Symbols that instructs the compiler to perform specific
arithmetic or logical operation on operands
●
All C operators do 2 things
– Operates on its operands
– Returns a value

Advanced C
Operators
Category
Operand
Operation
unary
ternary
Arithmetic
Logical
binary
+
!
Relational >
Assignment =
Bitwise &
Language sizeof()
Pointers *
- * / %
|| &&
< <= >= == !=
| ^ ~ >> <<
& ->
...
...
...
...

Advanced C
Operators – Precedence and Associativity
Operators Associativity Precedence
() [] -> . L - R HIGH
! ++ −− - + * & (type) sizeof∼ 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 LOW
Note:
post ++ and –-
operators have
higher precedence
than pre ++ and –-
operators
(Rel-99 spec)

Advanced C
Operators - Arithmetic
#include <stdio.h>
int main()
{
int num;
num = 7 - 4 * 3 / 2 + 5;
printf(“Result is %dn”, num);
return 0;
}
What will be
the output?
Operator Description Associativity
/
*
%
+
-
Division
Multiplication
Modulo
Addition
Subtraction
L to R
017_example.c

Advanced C
Operators – Language - sizeof()
#include <stdio.h>
int main()
{
int num = 5;
printf(“%u:%u:%un”, sizeof(int), sizeof num, sizeof 5);
return 0;
}
#include <stdio.h>
int main()
{
int num1 = 5;
int num2 = sizeof(++num1);
printf(“num1 is %d and num2 is %dn”, num1, num2);
return 0;
}
018_example.c
019_example.c

Advanced C
Operators – Language - sizeof()
●
3 reasons for why sizeof is not a function
– Any type of operands
– Type as an operand
– No brackets needed across operands

Advanced C
Type Conversion
Type
Conversion
Explicit (by programmer)
Implicit (by compiler)

Advanced C
Type Conversion Hierarchy
signed char
unsigned char
signed short
unsigned short
signed int
unsigned int
signed long
unsigned long
signed long long
unsigned long long
float
double
long double

Advanced C
Type Conversion - Implicit
●
Automatic Unary conversions
– The result of + and - are promoted to int if operands are
char and short
– The result of ~ and ! is integer
●
Automatic Binary conversions
– If one operand is of LOWER RANK (LR) data type & other is
of HIGHER RANK (HR) data type then LOWER RANK will be
converted to HIGHER RANK while evaluating the expression.
– Example: LR + HR LR converted to HR→

Advanced C
Type Conversion - Implicit
●
Type promotion
– LHS type is HR and RHS type is LR → int = char LR is promoted→
to HR while assigning
●
Type demotion
– LHS is LR and RHS is HR → int = float HR rank will be demoted→
to LR. Truncated

Advanced C
Type Conversion – Explicit (Type Casting)
#include <stdio.h>
int main()
{
int num1 = 5, num2 = 3;
float num3 = (float) num1 / num2;
printf(“nun3 is %fn”, num3);
return 0;
}
Syntax
(data_type) expression
020_example.c

Advanced C
Operators - Logical
#include <stdio.h>
int main()
{
int num1 = 1, num2 = 0;
if (++num1 || num2++)
{
printf(“num1 is %d num2 is %dn”, num1, num2);
}
num1 = 1, num2 = 0;
if (num1++ && ++num2)
{
}
else
{
}
return 0;
}
What will be
the output?
!
&&
||
Logical NOT
Logical AND
Logical OR
R to L
L to R
L to R
021_example.c

Advanced C
Operators – Circuit Logical
●
Have the ability to “short circuit” a calculation if the
result is definitely known, this can improve efficiency
– Logical AND operator ( && )
●
If one operand is false, the result is false.
– Logical OR operator ( || )
●
If one operand is true, the result is true.

Advanced C
Operators - Relational
#include <stdio.h>
int main()
{
float num1 = 0.7;
if (num1 == 0.7)
{
printf(“Yes, it is equaln”);
}
else
{
printf(“No, it is not equaln”);
}
return 0;
}
>
<
>=
<=
==
!=
Greater than
Lesser than
Greater than or equal
Lesser than or equal
Equal to
Not Equal to
L to R
What will be
the output?
022_example.c

Advanced C
Operators - Assignment
#include <stdio.h>
int main()
{
int num1 = 1, num2 = 1;
float num3 = 1.7, num4 = 1.5;
num1 += num2 += num3 += num4;
printf(“num1 is %dn”, num1);
return 0;
}
#include <stdio.h>
int main()
{
float num1 = 1;
if (num1 = 1)
{
printf(“Yes, it is equal!!n”);
}
else
{
printf(“No, it is not equaln”);
}
return 0;
}
023_example.c 024_example.c

Advanced C
Operators - Bitwise
●
Bitwise operators perform operations on bits
●
The operand type shall be integral
●
Return type is integral value

Advanced C
Operators - Bitwise
0x61
Value
0x13
0
0
1
0
1
0
0
1
0
0
0
0
0
1
1
1
00x60
Value
0x13
A
Operand
B
0x01 0 0 0 0 0 0 0 10x13A & B
& Bitwise AND
Bitwise ANDing of
all the bits in two
operands
0x61
Value
0x13
0
0
1
0
1
0
0
1
0
0
0
0
0
1
1
1
00x60
Value
0x13
A
Operand
B
0x73 0 1 1 1 0 0 1 10x13A | B
| Bitwise OR
Bitwise ORing of
all the bits in two
operands

Advanced C
Operators - Bitwise
0x61
Value
0x13
0
0
1
0
1
0
0
1
0
0
0
0
0
1
1
1
00x60
Value
0x13
A
Operand
B
0x72 0 1 1 1 0 0 1 00x13A ^ B
^ Bitwise XOR
Bitwise XORing of
all the bits in two
operands
0x61
Value
0 1 1 0 0 0 0 100x60
Value
A
Operand
0x9E 1 0 0 1 1 1 1 00x13~A
~ Compliment
Complimenting
all the bits of the
operand

Advanced C
Operators – Bitwise – Shift
Left Shift :
shift-expression << additive-expression
(left operand) (right operand)
Right Shift :
shift-expression >> additive-expression
(left operand) (right operand)
Syntax

Advanced C
Operators – Bitwise – Left Shift
'Value' << 'Bits Count'
●
Value : Is shift operand on which bit shifting effect to be
applied
●
Bits count : By how many bit(s) the given “Value” to be shifted
0x61Original value
0x84
A << 2
Resultant value
0000110 1
0100001 0
Say A = 0x61
Zero filling left shift

Advanced C
Operators – Bitwise – Right Shift
'Value' >> 'Bits Count'
●
Value : Is shift operand on which bit shifting effect to be
applied
●
Bits count : By how many bit(s) the given “Value” to be shifted
Zero filling right shift
0x61Original value
0x18
A >> 2
Resultant value
0000110 1
0011000 0
Say A = 0x61

Advanced C
Operators – Bitwise – Right Shift – Signed Valued
“Signed Value' >> 'Bits Count'
●
Same operation as mentioned in previous slide.
●
But the sign bits gets propagated.
Zero filling right shiftSign bit filling right shift
0xA1Original value
0xE8
A >> 2
Resultant value
0000101 1
0010111 0
Say A = -95

Advanced C
Operators - Bitwise
#include <stdio.h>
int main()
{
int count;
unsigned char iter = 0xFF;
for (count = 0; iter != 0; iter >>= 1)
{
if (iter & 01)
{
count++;
}
}
printf(“count is %dn”, count);
return 0;
}
025_example.c

Advanced C
Operators – Bitwise – Shift
●
Each of the operands shall have integer type
●
The integer promotions are performed on each of the
operands
●
If the value of the right operand is negative or is greater
than or equal to the width of the promoted left operand,
the behavior is undefined
●
Left shift (<<) operator : If left operand has a signed type
and nonnegative value, and (left_operand * (2^n)) is
representable in the result type, then that is the
resulting value; otherwise, the behavior is undefined

Advanced C
Operators – Bitwise - Shift
#include <stdio.h>
int main()
{
int x = 7, y = 7;
x = 7 << 32;
printf(“x is %xn”, x);
x = y << 32;
printf(“x is %xn”, x);
return 0;
}
●
The below example has undefined behaviour
026_example.c

Advanced C
Operators – Bitwise - Mask
●
If you want to create the below art assuming your are not
a good painter, What would you do?

Advanced C
●
Mask the area as shown, and use a brush or a spray paint
to fill the required area!

Advanced C
●
Fill the inner region

Advanced C
●
Remove the mask tape

Advanced C
●
So masking, technically means unprotecting the required
bits of register and perform the actions like
– Set Bit
– Clear Bit
– Get Bit
etc,..

Advanced C
0 1 1 0 0 0 0 10
0 1 0 1 1 1 1 11
0 6 5 4 3 2 1 07 Bit Position
0 1 0 0 0 0 0 10
0 1 0 0 0 0 0 10
0 0 1 0 0 0 0 00
0 1 1 0 0 0 0 10
The register to be modified
Mask to CLEAR 5th
bit position
The result
The register to be modified
Mask to SET 5th
bit position
The result
& Operator
| Operator

Advanced C
Operators – Bitwise - Shift
●
W.A.P to count set bits in a given number
●
W.A.P to print bits of given number
●
W.A.P to swap nibbles of given number

Advanced C
Operators – Ternary
Syntax
Condition ? Expression 1 : Expression 2;
#include <stdio.h>
int main()
{
int num1 = 10;
int num2 = 20;
int num3;
if (num1 > num2)
{
num3 = num1;
}
else
{
num3 = num2;
}
printf(“%dn”, num3);
return 0;
}
#include <stdio.h>
int main()
{
int num1 = 10;
int num2 = 20;
int num3;
num3 = num1 > num2 ? num1 : num2;
printf(“Greater num is %dn”, num3);
return 0;
}
027_example.c

Advanced C
Operators – Comma
●
The left operand of a comma operator is evaluated as a
void expression (result discarded)
●
Then the right operand is evaluated; the result has its
type and value
●
Comma acts as separator (not an operator) in following
cases -
– Arguments to function
– Lists of initializers (variable declarations)
●
But, can be used with parentheses as function arguments
such as -
– foo ((x = 2, x + 3)); // final value of argument is 5

Advanced C
Over and Underflow
●
8-bit Integral types can hold certain ranges of values
●
So what happens when we try to traverse this boundary?
Overflow
(127 + 1)
Underflow
(-128 - 1)

Advanced C
Overflow – Signed Numbers
0x7FOriginal value
0x80Resultant value
1111110 1
Say A = +127
1Add 0000000 1
0000001 0
Sign bit

Advanced C
Underflow – Signed Numbers
0x80Original value
0x7FResultant value
Say A = -128
-1Add
0000001 0
1111111 1
1111110 11
Spill over bit is discarded
Sign bit

Advanced C
Arrays – Know the Concept
Ends here
Starts here
A conveyor belt
Equally spaced
Defined length
Carry similar items
Index as 10th
item

Advanced C
Arrays – Know the Concept
Conveyor Belt
Top view
Last Element
End address
●
Total Elements
●
Fixed size
●
Contiguous Address
●
Elements are
accessed by
indexing
●
Legal access region
An Array
First Element
Start (Base) address

Advanced C
Arrays
Syntax
data_type name[SIZE];
Where SIZE represents number of elements
Memory occupied by array = (number of elements * size of an element)
= (SIZE * <size of data_type>)
Example
int age[5] = {10, 20, 30, 40, 50};
10 20 30 40 50
Index 1
Index 2
Index 3
Index 4
Index 5
baseaddr
baseaddr+4
baseaddr+8
baseaddr+12
baseaddr+16

Advanced C
Arrays – Points to be noted
●
An array is a collection of similar data type
●
Elements occupy consecutive memory locations (addresses)
●
First element with lowest address and the last element with
highest address
●
Elements are indexed from 0 to SIZE – 1. Example : 5
elements array (say array[5]) will be indexed from 0 to 4
●
Accessing out of range array elements would be “illegal
access”
– Example : Do not access elements array[-1] and array[SIZE]
●
Array size can't be altered at run time

Advanced C
Arrays – Why?
#include <stdio.h>
int main()
{
int num1 = 10;
int num2 = 20;
int num3 = 30;
int num4 = 40;
int num5 = 50;
return 0;
}
#include <stdio.h>
int main()
{
int num_array[5] = {10, 20, 30, 40, 50};
int index;
for (index = 0; index < 5; index++)
{
printf(“%dn”, num_array[index]);
}
return 0;
}
028_example.c

Advanced C
Arrays - Reading
#include <stdio.h>
int main()
{
int num_array[5] = {1, 2, 3, 4, 5};
int index;
index = 0;
do
{
printf(“Index %d has Element %dn”, index, num_array[index]);
index++;
} while (index < 5);
return 0;
}
029_example.c

Advanced C
Arrays - Storing
#include <stdio.h>
int main()
{
int num_array[5];
int index;
for (index = 0; index < 5; index++)
{
scanf(“%d”, &num_array[index]);
}
return 0;
}
030_example.c

Advanced C
Arrays - Initializing
#include <stdio.h>
int main()
{
int array1[5] = {1, 2, 3, 4, 5};
int array2[5] = {1, 2};
int array3[] = {1, 2};
int array4[]; /* Invalid */
printf(“%un”, sizeof(array1));
return 0;
}
031_example.c

Advanced C
Arrays – Copying
●
Can we copy 2 arrays? If yes how?
#include <stdio.h>
int main()
{
int array_org[5] = {1, 2, 3, 4, 5};
int array_bak[5];
int index;
array_bak = array_org;
if (array_bak == array_org)
{
printf(“Copiedn”);
}
return 0;
}
Waow!! so simple?
But can I do this
032_example.c

Advanced C
Arrays – Copying
●
No!! its not so simple to copy two arrays as put in the
previous slide. C doesn't support it!
●
Then how to copy an array?
●
It has to be copied element by element

Advanced C
Arrays – DIY
●
W.A.P to find the average of elements stored in a array.
– Read value of elements from user
– For given set of values : { 13, 5, -1, 8, 17 }
– Average Result = 8.4
●
W.A.P to find the largest array element
– Example 100 is the largest in {5, 100, -2, 75, 42}

Advanced C
Arrays – DIY
●
W.A.P to compare two arrays (element by element).
– Take equal size arrays
– Arrays shall have unique values stored in random order
– Array elements shall be entered by user
– Arrays are compared “EQUAL” if there is one to one
mapping of array elements value
– Print final result “EQUAL” or “NOT EQUAL”
Example of Equal Arrays :
– A[3] = {2, -50, 17}
– B[3] = {17, 2, -50}

Advanced C
Arrays – Oops!! what is this now?

Advanced C - Part 1

More Related Content

What's hot (20)

Similar to Advanced C - Part 1 (20)

More from Emertxe Information Technologies Pvt Ltd (20)

Recently uploaded (20)

Advanced C - Part 1