Advanced C - Part 2

Advanced C
Functions – What?
An activity that is natural to or the purpose of a person or
thing.
"bridges perform the function of providing access across water"
A relation or expression involving one or more variables.
"the function (bx + c)"
●
In programming languages it can be something which performs
a specific service
●
Generally a function has 3 properties
– Takes Input
– Perform Operation
– Generate Output
Source: Google

Advanced C
Functions – What?
Input
Output
f(x) = x + 1
x
Output
x + 1
2
3
2 + 1
x = 2

Advanced C
Functions – How to write
Syntax
return_data_type function_name(arg_1, arg_2, ..., arg_n)
{
/* Function Body */
}
Example
int foo(int arg_1, int arg_2)
{
}
Return data type as int
First parameter with int type
Second parameter with int type
List of function parameters

Advanced C
Functions – How to write
y = x + 1
int foo(int x)
{
int ret;
ret = x + 1;
return ret;
}
Example
Formal argumentsReturn from function

Advanced C
Functions – How to call
#include <stdio.h>
int main()
{
int x, y;
x = 2;
y = foo(x);
printf(“y is %dn”, y);
return 0;
}
int foo(int x)
{
int ret = 0;
ret = x + 1;
return ret;
}
The function call
001_example.c

Advanced C
Functions – Why?
●
Re usability
– Functions can be stored in library & re-used
– When some specific code is to be used more than once, at different
places, functions avoids repetition of the code.
●
Divide & Conquer
– A big & difficult problem can be divided into smaller sub-problems
and solved using divide & conquer technique
●
Modularity can be achieved.
●
Code can be easily understandable & modifiable.
●
Functions are easy to debug & test.
●
One can suppress, how the task is done inside the function,
which is called Abstraction

Advanced C
Functions – A complete look
#include <stdio.h>
int main()
{
int num1 = 10, num2 = 20;
int sum = 0;
sum = add_numbers(num1, num2);
printf(“Sum is %dn”, sum);
return 0;
}
int add_numbers(int num1, int num2)
{
int sum = 0;
sum = num1 + num2;
return sum;
}
The main function
The function call
Actual arguments
Formal arguments
`
Formal arguments
Return type
Formal argumentsReturn result from function and exit
Formal argumentsoperation
002_example.c

Advanced C
Functions – Ignoring return value
#include <stdio.h>
int main()
{
int num1 = 10, num2 = 20;
int sum = 0;
add_numbers(num1, num2);
return 0;
}
{
int sum = 0;
sum = num1 + num2;
return sum;
}
Ignored the return from function
In C, it is up to the programmer to
capture or ignore the return value
003_example.c

Advanced C
Functions – DIY
●
Write a function to calculate square a number
– y = x * x
●
Write a function to convert temperature given in degree
Fahrenheit to degree Celsius
– C = 5/9 * (F – 32)
●
Write a program to check if a given number is even or
odd. Function should return TRUE or FALSE

Advanced C
Function and the Stack
Linux OS
P1
User
Space
Kernel
Space
The Linux OS is divided into two major sections
●
User Space
●
Kernel Space
The user programs cannot access the kernel
space. If done will lead to segmentation
violation
Let us concentrate on the user space section
here

Advanced C
Linux OS
P1
User
Space
Kernel
Space
P1
P2
P3
.
.
.
P1
Pn-1
Pn
User Space
The User space contains
many processes
Every process will be
scheduled by the kernel
Each process will have its
memory layout discussed
in next slide

Advanced C
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
P1
P2
P3
.
.
.
P1
Pn-1
Pn
User Space
The memory segment of a
program contains four
major areas.
●
Text Segment
●
Stack
●
Data Segment
●
Heap

Advanced C
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
Adjoins the heap area and grow in opposite
area of heap when stack and heap pointer
meet (Memory Exhausted)
A “stack pointer” register tracks the top
of the stack; it is adjusted each time
a value is “pushed” onto the stack
Typically loaded at the higher part of
memory
The set of values pushed for one function
call is termed a “stack frame”

Advanced C
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Local Variables
Return Address
Parameter List
Memory Segments Stack Frame
A stack frame contain at least
of a return address

Advanced C
Function and the Stack – Stack Frames
int add_numbers(int n1, int n2)
{
int s = 0;
s = n1 + n2;
return s;
}
Stack Frame(s)
num1 = 10
num2 = 20
sum = 0
Return Address to the caller
main()
s = 0
add_numbers()Return Address to the main()
n1 = 10
n2 = 20
#include <stdio.h>
int main()
{
int num1 = 10, num2 = 20;
int sum = 0;
return 0;
}
002_example.c

Advanced C
Functions – Parameter Passing Types
Pass by Value Pass by reference
●
This method copies the actual value
of an argument into the formal
parameter of the function.
●
In this case, changes made to the
parameter inside the function have
no effect on the actual argument.
●
This method copies the address of
an argument into the formal
parameter.
●
Inside the function, the address is
used to access the actual argument
used in the call. This means that
changes made to the parameter
affect the argument.

Advanced C
Functions – Pass by Value
#include <stdio.h>
int add_numbers(int num1, int num2);
int main()
{
int num1 = 10, num2 = 20, sum;
return 0;
}
{
int sum = 0;
sum = num1 + num2;
return sum;
}
002_example.c

Advanced C
#include <stdio.h>
void modify(int num1)
{
num1 = num1 + 1;
}
int main()
{
int num1 = 10;
printf(“Before Modificationn”);
printf(“num1 is %dn”, num1);
modify(num1);
printf(“After Modificationn”);
printf(“num1 is %dn”, num1);
return 0;
}
004_example.c

Advanced C
Are you sure you understood the previous problem?
Are you sure you are ready to proceed further?
Do you know the prerequisite to proceed further?
If no let's get it cleared

Advanced C
Functions – Pass by Reference
#include <stdio.h>
void modify(int *iptr)
{
*iptr = *iptr + 1;
}
int main()
{
int num = 10;
printf(“num1 is %dn”, num);
modify(&num);
return 0;
}
005_example.c

Advanced C
Shell
(loader)
./a.out
main .text
modify .text
005_example.c
#include <stdio.h>
{
*iptr = *iptr + 1;
}
int main()
{
int num = 10;
modify(&num);
return 0;
}

Advanced C
Shell
(loader)
./a.out
main .text
modify .text
1
num = 10
Return Address
to caller
1000
1
#include <stdio.h>
{
*iptr = *iptr + 1;
}
int main()
{
int num = 10;
modify(&num);
return 0;
}
005_example.c

Advanced C
Shell
(loader)
./a.out
main .text
modify .text
1
num = 10
Return Address
to caller
1
1000
Return Address
to main
iptr = 1000
2
2
2000
&
#include <stdio.h>
{
*iptr = *iptr + 1;
}
int main()
{
int num = 10;
modify(&num);
return 0;
}
005_example.c

Advanced C
Shell
(loader)
./a.out
main .text
modify .text
1
num = 11
Return Address
to caller
1
1000
Return Address
to main
iptr = 1000
2
2
2000
*
#include <stdio.h>
{
*iptr = *iptr + 1;
}
int main()
{
int num = 10;
modify(&num);
return 0;
}
005_example.c

Advanced C
Functions – Pass by Reference - Advantages
●
Return more than one value from a function
●
Copy of the argument is not made, making it fast, even
when used with large variables like arrays etc.
●
Saving stack space if argument variables are larger
(example – user defined data types)

Advanced C
Functions – DIY (pass-by-reference)
●
Write a program to find the square and cube of a number
●
Write a program to swap two numbers
●
Write a program to find the sum and product of 2
numbers
●
Write a program to find the square of a number

Advanced C
Functions – Implicit int rule
#include <stdio.h>
int main()
{
dummy(20);
return 0;
}
/* minimum valid function */
dummy()
{
}
006_example.c
●
Compilers can assume that
return and function
parameter types are integers
●
The rule was introduced in
C89/90
●
This rule is discontinued in
C99
●
But, compilers still follow
the above rule to maintain
backward compatibility

Advanced C
Functions – Prototype – What?
●
Function prototype is signature of function specifying
– Number of function parameters and their types
– Return type of function

Advanced C
Functions – Prototype – Why?
●
Need of function prototype –
– Functions can be used in many files
– Functions can be compiled and added to library for
reuse purpose
– Compiler needs to know the signature of function
before it comes across the invocation of function
– In absence of prototype, compilers will apply “Implicit
int rule” which might lead to discrepancy with
function parameters and return type in actual
definition

Advanced C
Functions – Passing Array
●
As mentioned in previous slide passing an array to
function can be faster
●
But before you proceed further it is expected you are
familiar with some pointer rules
●
If you are OK with your concepts proceed further, else
please know the rules first

Advanced C
#include <stdio.h>
void print_array(int array[]);
int main()
{
int array[5] = {10, 20, 30, 40, 50};
print_array(array);
return 0;
}
void print_array(int array[])
{
int iter;
for (iter = 0; iter < 5; iter++)
{
printf(“Index %d has Element %dn”, iter, array[iter]);
}
}
007_example.c

Advanced C
#include <stdio.h>
void print_array(int *array);
int main()
{
int array[5] = {10, 20, 30, 40, 50};
print_array(array);
return 0;
}
void print_array(int *array)
{
int iter;
{
printf(“Index %d has Element %dn”, iter, *array);
array++;
}
}
008_example.c

Advanced C
#include <stdio.h>
void print_array(int *array, int size);
int main()
{
int array[5] = {10, 20, 30, 40, 50};
print_array(array, 5);
return 0;
}
void print_array(int *array, int size)
{
int iter;
for (iter = 0; iter < size; iter++)
{
printf(“Index %d has Element %dn”, iter, *array++);
}
}
009_example.c

Advanced C
Functions – Returning Array
#include <stdio.h>
int *modify_array(int *array, int size);
void print_array(int array[], int size);
int main()
{
int array[5] = {10, 20, 30, 40, 50};
int *new_array_val;
new_array_val = modify_array(array, 5);
print_array(new_array_val, 5);
return 0;
}
void print_array(int array[], int size)
{
int iter;
{
}
}
int *modify_array(int *array, int size)
{
int iter;
{
*(array + iter) += 10;
}
return array;
}
010_example.c

Advanced C
Functions – Returning Array
#include <stdio.h>
int *return_array(void);
void print_array(int *array, int size);
int main()
{
int *array_val;
array_val = return_array();
print_array(array_val, 5);
return 0;
}
void print_array(int *array, int size)
{
int iter;
{
}
}
int *return_array(void)
{
static int array[5] = {10, 20, 30, 40, 50};
return array;
}
011_example.c

Advanced C
Functions – DIY
●
Write a program to find the average of 5 array elements
using function
●
Write a program to square each element of array which
has 5 elements

Advanced C
Functions – Local Return
#include <stdio.h>
int *func(void)
{
int a = 10;
return &a;
}
int main()
{
int *ptr;
ptr = func();
printf(“Hello Worldn”);
printf(“*ptr = %dn”, *ptr);
return 0;
}
012_example.c

Advanced C
Functions – Void Return
#include <stdio.h>
void func(void)
{
printf(“Welcome!n”);
return; // Use of return is optional
}
int main()
{
func();
return 0;
}
013_example.c

Advanced C
Functions – Void Return
#include <stdio.h>
int main()
{
printf(“%sn”, func()); // Error, invalid use of a function returning void
return 0;
}
void func(void)
{
char buff[] = “Hello World”;
return buff; // some compilers might report error in this case
}
014_example.c

Advanced C
Functions – Recursive
●
Recursion is the process of repeating items in a self-similar
way
●
In programming a function calling itself is called as recursive
function
●
Two steps
Step 1: Identification of base case
Step 2: Writing a recursive case

Advanced C
Functions – Recursive – Example
#include <stdio.h>
/* Factorial of 3 numbers */
int factorial(int number)
{
if (number <= 1) /* Base Case */
{
return 1;
}
else /* Recursive Case */
{
return number * factorial(number – 1);
}
}
int main()
{
int ret;
ret = factorial(3);
printf(“Factorial of 3 is %dn”, ret);
return 0;
}
n !n
0 1
1 1
2 2
3 6
4 24
015_example.c

Embedded C
Functions – Recursive – Example Flow
Shell
(loader)
./a.out
Return Address
to main
2
number = 3
2
number != 1
number * factorial(number -1)
3 * factorial(3 -1)
3
4
number = 2
Return Address
to factorial3
number != 1
number * factorial(number -1)
2 * factorial(2 -1)
number = 1
Return Address
to factorial4 number == 1
result
Return Address
to caller
1 factorial(3)
Main .text
factorial .text
1
Stack Frames Value with calls

Embedded C
Functions – Recursive – Example Flow
Shell
(loader)
./a.out
Return Address
to main
2
number = 3
2
Returns 3 * 2 to the caller
3
number = 2
Return Address
to factorial3 Returns 2 * 1 to the caller
number = 1
Return Address
to factorial4 returns 1 to the caller
result
Return Address
to caller
1 Gets 6 a value
Main .text
factorial .text
1
Stack Frames Results with return
4

Advanced C
Functions – DIY
●
Write a program to find the sum of sequence of N
numbers starting from 1
●
Write a program to find x raise to the power of y ( xy )
– Example : 23 = 8
●
Write a program to find the sum of digits of a given
number
– Example : if given number is 10372, the sum of digits
will be 1+0+3+9+2 = 15

Advanced C
Pointers – Jargon
●
What's a Jargon?
– Jargon may refer to terminology used in a certain
profession, such as computer jargon, or it may refer to any
nonsensical language that is not understood by most
people.
– Speech or writing having unusual or pretentious vocabulary,
convoluted phrasing, and vague meaning.
●
Pointer are perceived difficult
– Because of “jargonification”
●
So, let's “dejargonify” & understand them

Advanced C
Pointers – Analogy with Book
Front matter
Notes Section
Indexes
Contains pages
A Book
Boot Code
Data & Stack
Pointers to specific memory locations
Memory Pages
System Memory
Table of Contents Pointer to different programs
Chapters Code Segments

Advanced C
Pointers – Computers
●
Just like a book analogy, Computers contains different
different sections (Code) in the memory
●
All sections have different purposes
●
Every section has a address and we need to point to them
whenever required
●
In fact everything (Instructions and Data) in a particular
section has an address!!
●
So the pointer concept plays a big role here

Advanced C
Pointers – Why?
●
To have C as a low level language being a high level
language
●
Returning more than one value from a function
●
To achieve the similar results as of ”pass by value”
●
parameter passing mechanism in function, by passing the
reference
●
To have the dynamic allocation mechanism

Advanced C
Pointers – The 7 Rules
●
Rule 1 - Pointer is an Integer
●
Rule 2 - Referencing and De-referencing
●
Rule 3 - Pointing means Containing
●
Rule 4 - Pointer Type
●
Rule 5 - Pointer Arithmetic
●
Rule 6 - Pointing to Nothing
●
Rule 7 - Static vs Dynamic Allocation

Advanced C
Pointers – The 7 Rules – Rule 1
CPU
RAM
Integer i;
Pointer p;
Say:
i = 6;
p = 6;
6
6
i
p

Advanced C
●
Whatever we put in data bus is Integer
●
Whatever we put in address bus is Pointer
●
So, at concept level both are just numbers. May be of
different sized buses
●
Rule: “Pointer is an Integer”
●
Exceptions:
– May not be address and data bus of same size
– Rule 2 (Will see why? while discussing it)

Advanced C
Pointers – Rule 1 in detail
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
ptr = 5;
return 0;
}
?1000 Say 4 bytes
x
?2000 Say 4 bytes
ptr
001_example.c

Advanced C
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
ptr = 5;
return 0;
}
51000 Say 4 bytes
x
52000 Say 4 bytes
ptr
●
So pointer is an integer
●
But remember the “They may not be of same size”
32 bit system = 4 Bytes
64 bit system = 8 Bytes
001_example.c

Advanced C
●
Rule : “Referencing and Dereferencing”
Variable Address
&
*

Advanced C
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
return 0;
}
51000 Say 4 bytes
x
?2000 Say 4 bytes
ptr
●
Considering the image, What would the below line mean?
* 1000
002_example.c

Advanced C
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
return 0;
}
51000 Say 4 bytes
x
?2000 Say 4 bytes
ptr
●
Considering the image, What would the below line mean?
* 1000
●
Goto to the location 1000 and fetch its value, so
* 1000 5→
002_example.c

Advanced C
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
ptr = &x;
return 0;
}
51000 Say 4 bytes
x
?2000 Say 4 bytes
ptr
●
What should be the change in the above diagram for the
above code?
002_example.c

Advanced C
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
ptr = &x;
return 0;
}
51000 Say 4 bytes
x
10002000 Say 4 bytes
ptr
●
So pointer should contain the address of a variable
●
It should be a valid address
002_example.c

Advanced C
#include <stdio.h>
int main()
{
int x;
int *ptr;
x = 5;
ptr = &x;
return 0;
}
51000
x
10002000
ptr
“Prefix 'address of operator' (&) with variable (x) to get its
address and store in the pointer”
“Prefix 'indirection operator' (*) with pointer to get the value of
variable (x) it is pointing to”
& *
002_example.c

Advanced C
#include <stdio.h>
int main()
{
int number = 10;
int *ptr;
ptr = &number;
printf(“Address of number is %pn”, &number);
printf(“ptr contains %pn”, ptr);
return 0;
}
003_example.c

Advanced C
#include <stdio.h>
int main()
{
int number = 10;
int *ptr;
ptr = &number;
printf(“number contains %dn”, number);
printf(“*ptr contains %dn”, *ptr);
return 0;
}
004_example.c

Advanced C
#include <stdio.h>
int main()
{
int number = 10;
int *ptr;
ptr = &number;
*ptr = 100;
printf(“number contains %dn”, number);
printf(“*ptr contains %dn”, *ptr);
return 0;
}
●
So, from the above code we can conclude
“*ptr <=> number”
005_example.c

Advanced C
●
Pointer pointing to a Variable = Pointer contains the
Address of the Variable
●
Rule: “Pointing means Containing”
10
1000
1000
1004
1008
1012
1016
1020
1024
a
ptr
#include <stdio.h>
int main()
{
int a = 10;
int *ptr;
ptr = &a;
return 0;
}
Example

Advanced C
●
Types to the pointers
●
What??, why do we need types attached to pointers?

Advanced C
#include <stdio.h>
int main()
{
int num = 1234;
char ch;
return 0;
}
12341000 4 bytes
num
?1004 1 bytes
ch
●
Does address has a type?
●
So from the above diagram can we say &num 4 bytes→
and &ch 1 byte?→
Example

Advanced C
●
The answer is no!!
●
Address size does not
depend on type of the
variable
●
It depends on the system
we use and remains same
across all pointers
●
Then a simple questions
arises “why type is used
with pointers?”
1000
1004
1008
1012
1016
1020
1024
num
ch

Advanced C
#include <stdio.h>
int main()
{
int num = 1234;
char ch;
int *iptr;
char *cptr;
return 0;
}
1234
1000
num
?
1004
ch
●
Lets consider above example to understand it
●
Say we have an integer and a character pointer
?
2000
iptr
?
2004
cptr
Example

Advanced C
#include <stdio.h>
int main()
{
int num = 1234;
char ch;
int *iptr = &num;
char *cptr = &ch;
return 0;
}
1234
1000
num
?
1004
ch
●
Lets consider the above examples to understand it
●
Say we have a integer and a character pointer
1000
2000
iptr
1004
2004
cptr
Example

Advanced C
1234
1000
num
?
1004
ch
●
With just the address, can
we know what data is
stored?
●
How would we know how
much data to fetch for the
address it is pointing to?
●
Eventually the answer would
be NO!!
1000
2000
iptr
1004
2004
cptr

Advanced C
1234
1000
num
?
1004
ch
●
From the diagram right side
we can say
*cptr fetches a single byte
*iptr fetches 4 consecutive
bytes
●
So, in conclusion we can say
1000
2000
iptr
1004
2004
cptr
(type *) fetch sizeof(type) bytes→

Advanced C
Pointers – Rule 4 in detail - Endianness
●
Since the discussion is on the data fetching, its better
we have knowledge of storage concept of machines
●
The Endianness of the machine
●
What is this now!!?
– Its nothing but the byte ordering in a word of the
machine
●
There are two types
– Little Endian – LSB in Lower Memory Address
– Big Endian – MSB in Lower Memory Address

Advanced C
●
LSB (Least Significant Byte)
– The byte of a multi byte number with the least
importance
– The change in it would have least effect on number's
value change
●
MSB (Most Significant Byte)
– The byte of a multi byte number with the most
importance
– The change in it would have larger effect on number's
value change

Advanced C
●
Let us consider the following
example and how it would be
stored in both machine types
#include <stdio.h>
int main()
{
int num = 0x12345678;
return 0;
}
1000
1004
78 56 34 12
num
1000
1004
12 34 56 78
num
Big Endian
Little Endian
1000
1000
78 56 34 12
12 34 56 78
1001
1001
1002
1002
1003
1003
→
→
Example

Advanced C
●
OK Fine. What now? How is it going to affect the fetch
and modification?
●
Let us consider the same example put in the previous
slide
#include <stdio.h>
int main()
{
int num = 0x12345678;
int *iptr, char *cptr;
iptr = &num;
cptr = &num;
return 0;
}
●
First of all is it possible to
access a integer with character
pointer?
●
If yes, what should be the
effect on access?
●
Let us assume a Litte Endian
system
Example

Advanced C
1000
78 56 34 12
num
1000
1000
2000 iptr
2004 cptr
*iptr = 0x12345678 *cptr = 0x78
●
So from the above diagram it should be clear that when we do
cross type accessing, the endianness should be considered
1000
78 56 34 12
num
1000
2000 iptr
1000
78 56 34 12
num
1000
2004 cptr

Advanced C
●
So changing *cptr will change only
the byte its pointing to
#include <stdio.h>
int main()
{
int num = 0x12345678;
char ch;
int *iptr = &num;
char *cptr = &num;
*cptr = 0x12;
return 0;
}
*cptr = 0x12
1000
12 56 34 12
num
1000
2004 cptr
●
So *iptr would contain 0x12345612
now!!
Example

Advanced C
●
In conclusion,
– The type of a pointer represents it's ability to perform
read or write operations on number of bytes (data)
starting from address its pointing to
– Size of all different type pointers remains same
#include <stdio.h>
int main()
{
if (sizeof(char *) == sizeof(long long *))
{
printf(“Yes its Equaln”);
}
return 0;
}
006_example.c

Advanced C
Pointers – The 7 Rules – Rule 4 - DIY
●
WAP to check whether a machine is Little or Big Endian

Advanced C
●
Pointer Arithmetic
Rule: “Value(p + i) = Value(p) + i * sizeof(*p)”

Advanced C
Pointers – The Rule 5 in detail
●
Before proceeding further let us understand an array
interpretation
– Original Big Variable (bunch of variables, whole array)
– Constant Pointer to the 1st Small Variable in the bunch
(base address)
●
When first interpretation fails than second interpretation
applies

Advanced C
●
Cases when first interpretation applies
– When name of array is operand to sizeof operator
– When “address of operator (&)” is used with name of array
while performing pointer arithmetic
●
Following are the cases when first interpretation fails
– When we pass array name as function argument
– When we assign an array variable to pointer variable

Advanced C
#include <stdio.h>
int main()
{
int array[5] = {1, 2, 3, 4, 5};
int *ptr = array;
return 0;
}
1
2
3
4
5
1000
1000
1004
1008
1012
1016
1020
1024
ptr
●
So,
Address of array = 1000
Base address = 1000
&array[0] = 1 1000→
&array[1] = 2 1004→
array
007_example.c

Advanced C
#include <stdio.h>
int main()
{
int array[5] = {1, 2, 3, 4, 5};
int *ptr = array;
printf(“%dn”, *ptr);
return 0;
}
1
2
3
4
5
1000
1000
1004
1008
1012
1016
1020
1024
array
ptr
●
This code should print 1 as output
since its points to the base address
●
Now, what should happen if we do
ptr = ptr + 1;
007_example.c

Advanced C
1
2
3
4
5
1004
1000
1004
1008
1012
1016
1020
1024
array
ptr
●
ptr = ptr + 1;
●
The above line can be described as
follows
●
ptr = ptr + 1 * sizeof(data type)
●
In this example we have a integer
array, so
●
ptr = ptr + 1 * sizeof(int)
ptr = ptr + 1 * 4
ptr = ptr + 4
●
Here ptr = 1000 so
ptr = 1000 + 4
ptr = 1004

Advanced C
1
2
3
4
5
1008
1000
1004
1008
1012
1016
1020
1024
array
ptr
ptr = ptr + 2;
1
2
3
4
5
1012
1000
1004
1008
1012
1016
1020
1024
array
ptr
ptr = ptr + 3;
1
2
3
4
5
1016
1000
1004
1008
1012
1016
1020
1024
array
ptr
ptr = ptr + 4;
●
Why does the compiler does this? Just for convenience

Advanced C
●
For array, it can be explained as
ptr + 2
ptr + 2 * sizeof(int)
1000 + 2 * 4
1008 &array[2]→
●
So,
ptr + 2 1008 &array[2]→ →
*(ptr + 2) *(1008) array[2]→ →
1
2
3
4
5
1008
1000
1004
1008
1012
1016
1020
1024
array
ptr
ptr = ptr + 2;

Advanced C
●
So to access an array element using a pointer would be
*(ptr + i) array[i]→
●
This can be written as following too!!
array[i] *(array + i)→
●
Which results to
ptr = array
●
So, in summary, the below line also becomes valid
because of second array interpretation
int *ptr = array;

Advanced C
●
Wait can I write
*(ptr + i) *(i + ptr)→
●
Yes. So than can I write
array[i] i[array]→
●
Yes. You can index the element in both the ways

Advanced C
●
Rule: “Pointer value of NULL or Zero = Null Addr = Null
Pointer = Pointing to Nothing”

Advanced C
Pointers – Rule 6 in detail – NULL Pointer
#include <stdio.h>
int main()
{
int *num;
return 0;
}
Example
?1000 4 bytes
num
?
?
?
?
?
Where am I
pointing to?
What does it
Contain?
Can I read or
write wherever
I am pointing?

Advanced C
●
Is it pointing to the valid address?
●
If yes can we read or write in the location where its
pointing?
●
If no what will happen if we access that location?
●
So in summary where should we point to avoid all this
questions if we don't have a valid address yet?
●
The answer is Point to Nothing!!

Advanced C
●
Now what is Point to Nothing?
●
A permitted location in the system will always give predictable
result!
●
It is possible that we are pointing to some memory location
within our program limit, which might fail any time! Thus
making it bit difficult to debug.
●
An act of initializing pointers to 0 (generally, implementation
dependent) at definition.
●
0??, Is it a value zero? So a pointer contain a value 0?
●
Yes. On most of the operating systems, programs are not
permitted to access memory at address 0 because that
memory is reserved by the operating system

Advanced C
●
In pointer context, an integer constant expression with
value zero or such an expression typecast to void * is called
null pointer constant or NULL
– [defined as 0 or (void *)0 ]
●
If a pointer is initialized with null pointer constant, it is
called null pointer
●
A Null Pointer is logically understood to be Pointing to
Nothing
●
De-referencing a NULL pointer is illegal and will lead to
crash (segment violation on Linux or reboot on custom
board), which is better than pointing to some unknown
location and failing randomly!

Advanced C
●
Need for Pointing to 'Nothing'
– Terminating Linked Lists
– Indicating Failure by malloc, ...
●
Solution
– Need to reserve one valid value
– Which valid value could be most useless?
– In wake of OSes sitting from the start of memory, 0 is a
good choice
– As discussed in previous sides it is implementation
dependent

Advanced C
#include <stdio.h>
int main()
{
int *num;
num = NULL;
return 0;
}
Example
#include <stdio.h>
int main()
{
int *num = NULL;
return 0;
}
Example

Advanced C
Pointers – Void Pointer
●
A pointer with incomplete type
●
Due to incomplete type
– Pointer arithmetic can’t be performed
– Void pointer can't be dereferenced. You MUST use type
cast operator “(type)” to dereference

Advanced C
Pointers – Size of void – Compiler Dependency
:GCC Extension:
6.22 Arithmetic on void- and Function-Pointers
In GNU C, addition and subtraction operations are supported
on “pointers to void” and on “pointers to functions”. This is
done by treating the size of a void or of a function as 1.
A consequence of this is that sizeof is also allowed on void and
on function types, and returns 1.
The option -Wpointer-arith requests a warning if these
extensions are used

Advanced C
Pointers – Void Pointer - Size of void
●
Due to gcc extension, size of void is 1
●
Hence, gcc allows pointer arithmetic on void pointer
●
Don’t forget! Its compiler dependent!
Note: To make standard compliant, compile using gcc -pedantic-errors

Advanced C
●
A generic pointer which can point to data in memory
●
The data type has to be mentioned while accessing the
memory which has to be done by type casting
#include <stdio.h>
int main()
{
void *vptr;
return 0;
}
?2000
vptr
Example

Advanced C
#include <stdio.h>
int main()
{
double x = 7.2;
void *vptr = &x;
return 0;
}
20001000
0xCC
0xCC
0x1C
0x40
2000 0xCD
0xCC
0xCC
0xCC
x
2001
2002
2003
2004
2005
2006
2007
●
vptr is a void pointer pointing to
address of x which holds floating
point data with double type
●
These eights bytes are the legal
region to the vptr
●
We can access any byte(s) within
this region by type casting
vptr
008_example.c

Advanced C
#include <stdio.h>
int main()
{
double x = 7.2;
void *vptr = &x;
printf(“%hhxn”, *(char *)vptr);
printf(“%hhxn”, *(char *)(vptr + 7));
printf(“%hun”, *(short *)(vptr + 3));
printf(“%xn”, *(int *)(vptr + 0));
return 0;
}
20001000
vptr
0xCC
0xCC
0x1C
0x40
2000 0xCD
0xCC
0xCC
0xCC
x
2001
2002
2003
2004
2005
2006
2007
008_example.c

Advanced C
●
W.A.P to swap any given data type

Advanced C
●
Rule: “Static Allocation vs Dynamic Allocation”
#include <stdio.h>
int main()
{
char array[5];
return 0;
}
Example
#include <stdio.h>
int main()
{
char *ptr;
ptr = malloc(5);
return 0;
}
Example

Advanced C
●
Named vs Unnamed Allocation = Named vs Unnamed Houses
1 2 3 4 5 6 7 8
Ok, House 1, I should go that side ←
Ok, House 1, I should go??? Oops

Advanced C
●
Managed by Compiler vs User
●
Compiler
– The compiler will allocate the required memory
internally
– This is done at the time of definition of variables
●
User
– The user has to allocate the memory whenever
required and deallocate whenever required
– This done by using malloc and free

Advanced C
●
Static vs Dynamic
#include <stdio.h>
int main()
{
int num, *num_ptr, *ptr;
num_ptr = &num;
ptr = malloc(4);
return 0;
}
Example
?2000 4 bytes
num_ptr
?1000
num
?2004 4 bytes
ptr

Advanced C
●
Static vs Dynamic
#include <stdio.h>
int main()
{
num_ptr = &num;
ptr = malloc(4);
return 0;
}
10002000 4 bytes
num_ptr
?1000
num
?2004 4 bytes
ptr
Example

Advanced C
●
Static vs Dynamic
#include <stdio.h>
int main()
{
num_ptr = &num;
ptr = malloc(4);
return 0;
}
10002000 4 bytes
num_ptr
?
?
?
?
?
?1000
num
5002004 4 bytes
ptr
500
Example

Advanced C
Pointers – Rule 7 in detail - Dynamic Allocation
●
The need
– You can decide size of the memory at run time
– You can resize it whenever required
– You can decide when to create and destroy it

Advanced C
Pointers – Rule 7 – Dynamic Allocation - malloc
Prototype
void *malloc(size_t size);
●
Allocates the requested size of memory from the heap
●
The size is in bytes
●
Returns the pointer of the allocated memory on success,
else returns NULL pointer

Advanced C
?
?
?
?
?
5001000
ptr
500
?
?
?
?
?
#include <stdio.h>
int main()
{
char *ptr;
ptr = malloc(5);
return 0;
}
Allocate 5 Bytes
Example

Advanced C
?
?
?
?
?
NULL1000
ptr
?
?
?
?
?
#include <stdio.h>
int main()
{
char *ptr;
ptr = malloc(10);
return 0;
}
Only 7 Bytes
Available!!
So returns
NULL
NULL
Example

Advanced C
Pointers – Rule 7 – Dynamic Allocation - calloc
Prototype
void *calloc(size_t nmemb, size_t size);
●
Allocates memory blocks large enough to hold "n
elements" of "size" bytes each, from the heap
●
The allocated memory is set with 0's
●

Advanced C
Pointers – Rule 7 – Dynamic Allocation - calloc
0
0
0
?
?
5001000
ptr
500
?
?
?
0
0
#include <stdio.h>
int main()
{
char *ptr;
ptr = calloc(5, 1);
return 0;
}
Allocate 5 Bytes
and all are set
to zeros
Example

Advanced C
Pointers – Rule 7 – Dynamic Allocation - realloc
Prototype
void *realloc(void *ptr, size_t size);
●
Changes the size of the already allocated memory by
malloc or calloc.
●

Advanced C
?
?
?
?
?
5001000
ptr
500
?
?
?
?
?
Allocate 5 Bytes
#include <stdio.h>
int main()
{
char *ptr;
ptr = malloc(5);
ptr = realloc(ptr, 7);
return 0;
}
Example

Advanced C
?
?
?
?
?
5001000
ptr
500
?
?
?
?
? Existing memory
gets extended to
7 bytes
#include <stdio.h>
int main()
{
char *ptr;
ptr = malloc(5);
return 0;
}
Example

Advanced C
?
?
?
?
?
5001000
ptr
500
?
?
?
?
? Existing memory
gets shrinked to
2 bytes
#include <stdio.h>
int main()
{
char *ptr;
ptr = malloc(5);
return 0;
}
Example

Advanced C
●
Points to be noted
– Reallocating existing memory will be like deallocating
the allocated memory
– If the requested chunk of memory cannot be
extended in the existing block, it would allocate in a
new free block starting from different memory!
– If new memory block is allocated then old memory
block is automatically freed by realloc function

Advanced C
Pointers – Rule 7 – Dynamic Deallocation - free
Prototype
void free(void *ptr);
●
Frees the allocated memory, which must have been
returned by a previous call to malloc(), calloc() or realloc()
●
Freeing an already freed block or any other block, would
lead to undefined behaviour
●
Freeing NULL pointer has no effect.
●
If free() is called with invalid argument, might collapse the
memory management mechanism
●
If free is not called after dynamic memory allocation, will
lead to memory leak

Advanced C
?
?
?
?
?
?1000
ptr
?
?
?
?
?
#include <stdio.h>
int main()
{
char *ptr;
int iter;
ptr = malloc(5);
{
ptr[iter] = 'A' + iter;
}
free(ptr);
return 0;
}
Example

#include <stdio.h>
int main()
{
char *ptr;
int iter;
ptr = malloc(5);
{
}
free(ptr);
return 0;
}
Advanced C
?
?
?
?
?
5001000
ptr
?
?
?
?
?
500
Example

#include <stdio.h>
int main()
{
char *ptr;
int iter;
ptr = malloc(5);
{
}
free(ptr);
return 0;
}
Advanced C
C
B
A
?
?
5001000
ptr
?
?
?
E
D
500
Example

Advanced C
●
Points to be noted
– Free releases the allocated block, but the pointer
would still be pointing to the same block!!, So
accessing the freed block will have undefined
behaviour.
– This type of pointer which are pointing to freed
locations are called as Dangling Pointers
– Doesn't clear the memory after freeing

Advanced C
Pointers – Rule 7 – DIY
●
Implement my_strdup function

Advanced C
Pointers – Const Pointer
#include <stdio.h>
int main()
{
int const *num = NULL;
return 0;
}
Example
The location, its pointing to is
constant
#include <stdio.h>
int main()
{
int *const num = NULL;
return 0;
}
Example
The pointer is constant

Advanced C
#include <stdio.h>
int main()
{
const int *const num = NULL;
return 0;
}
Both constants
Example

Advanced C
#include <stdio.h>
int main()
{
const int num = 100;
int *iptr = &num;
printf(“Number is %dn”, *iptr);
*iptr = 200;
printf(“Number is %dn”, num);
return 0;
}
Example

Advanced C
#include <stdio.h>
int main()
{
int num = 100;
const int *iptr = &num;
printf(“Number is %dn”, num);
num = 200;
printf(“Number is %dn”, *iptr);
return 0;
}
Example

Advanced C
Pointers – Do's and Dont's
#include <stdio.h>
int main()
{
char *ptr = malloc(5);
ptr = ptr + 10; /* Yes */
ptr = ptr - 10; /* Yes */
return 0;
}
?
?
?
?
?
5001000
ptr
500
?
?
?
?
?
501
502
503
504
505
506
507
508
509
?510
●
malloc(5) allocates a block of
5 bytes as shown
Example

Advanced C
#include <stdio.h>
int main()
{
ptr = ptr + 10; /* Yes */
ptr = ptr - 10; /* Yes */
return 0;
}
?
?
?
?
?
5101000
ptr
500
?
?
?
?
?
501
502
503
504
505
506
507
508
509
?510
●
Adding 10 to ptr we will
advance 10 bytes from the
base address which is illegal
but no issue in compilation!!
Example

Advanced C
#include <stdio.h>
int main()
{
ptr = ptr + 10; /* Yes */
ptr = ptr - 10; /* Yes */
return 0;
}
?
?
?
?
?
5001000
ptr
500
?
?
?
?
?
501
502
503
504
505
506
507
508
509
?510
●
Subtracting 10 from ptr we
will retract 10 bytes to the
base address which is
perfectly fine
Example

Advanced C
#include <stdio.h>
int main()
{
ptr = ptr * 1; /* No */
ptr = ptr / 1; /* No */
return 0;
}
●
All these operation on the
ptr will be illegal and would
lead to compiler error!!
●
In fact most of the binary
operator would lead to
compilation error
Example

Advanced C
#include <stdio.h>
int main()
{
ptr = ptr + ptr; /* No */
ptr = ptr * ptr; /* No */
ptr = ptr / ptr; /* No */
return 0;
}
●
All these operation on the
ptr will be illegal and would
lead to compiler error!!
●
In fact most of the binary
operator would lead to
compilation error
Example

Advanced C
#include <stdio.h>
int main()
{
ptr = ptr - ptr;
return 0;
}
●
What is happening here!?
●
Well the value of ptr would
be 0, which is nothing but
NULL (Most of the
architectures) so it is
perfectly fine
●
The compiler would compile
the code with a warning
though
Example

Advanced C
Pointers – Pitfalls – Segmentation Fault
●
A segmentation fault occurs when a program attempts to
access a memory location that it is not allowed to access, or
attempts to access a memory location in a way that is not
allowed.
#include <stdio.h>
int main()
{
int num = 0;
printf(“Enter the numbern”);
scanf(“%d”, num);
return 0;
}
Example
#include <stdio.h>
int main()
{
int *num = 0;
printf(“The number is %dn”, *num);
return 0;
}
Example

Advanced C
Pointers – Pitfalls – Dangling Pointer
●
A dangling pointer is something which does not point to a valid
location any more.
#include <stdio.h>
int main()
{
int *num_ptr;
num_ptr = malloc(4);
free(num_ptr);
*num_ptr = 100;
return 0;
}
Example
#include <stdio.h>
int *foo()
{
int num_ptr;
return &num_ptr;
}
int main()
{
int *num_ptr;
num_ptr = foo();
return 0;
}
Example

Advanced C
Pointers – Pitfalls – Wild Pointer
●
An uninitialized pointer pointing to a invalid location can be
called as an wild pointer.
#include <stdio.h>
int main()
{
int *num_ptr_1; /* Wild Pointer */
static int *num_ptr_2; / Not a wild pointer */
return 0;
}
Example

Advanced C
Pointers – Pitfall - Memory Leak
●
Improper usage of the memory allocation will lead to
memory leaks
●
Failing to deallocating memory which is no longer needed
is one of most common issue.
●
Can exhaust available system memory as an application
runs longer.

Advanced C
Pointers – Pitfall - Memory Leak
#include <stdio.h>
int main()
{
int *num_array, sum = 0, no_of_elements, iter;
while (1)
{
printf(“Enter the number of elements: n”);
scanf(“%d”, &no_of_elements);
num_array = malloc(no_of_elements * sizeof(int));
sum = 0;
for (iter = 0; iter < no_of_elements; iter++)
{
scanf(“%d”, &num_array[iter]);
sum += num_array[iter];
}
printf(“The sum of array elements are %dn”, sum);
/* Forgot to free!! */
}
return 0;
}
Example

Advanced C
Pointers – Pitfalls – Bus Error
●
A bus error is a fault raised by hardware, notifying an
operating system (OS) that, a process is trying to access
memory that the CPU cannot physically address: an invalid
address for the address bus, hence the name.
#include <stdio.h>
int main()
{
char array[sizeof(int) + 1];
int *ptr1, *ptr2;
ptr1 = &array[0];
ptr2 = &array[1];
scanf(“%d %d”, ptr1, ptr2);
return 0;
}
Example

Advanced C
Standard I/O – Why should I know this? - DIY
user@user:~]
user@user:~]./print_bill.out
Enter the item 1: Kurkure
Enter no of pcs: 2
Enter the cost : 5
Enter the item 2: Everest Paneer Masala
Enter no of pcs: 1
Enter the cost : 25.50
Enter the item 3: India Gate Basmati
Enter no of pcs: 1
--------------------------------------------------------------------------
S.No Name Quantity Cost Amount
--------------------------------------------------------------------------
1. Kurkure 2 5.00          10.00
2. Everest Paneer 1          25.50 25.50
2. India Gate Bas 1          1050.00 1050.00
--------------------------------------------------------------------------
Total          4 1085.50
--------------------------------------------------------------------------
user@user:~]
Screen Shot

Advanced C
Standard I/O
Text Terminal
STDOUT
STDIN
Program
STDERR

Advanced C
Standard I/O – The File Descriptors
●
OS uses 3 file descriptors to provide standard input
output functionalities
– 0 stdin→
– 1 stdout→
– 2 stderr→
●
These are sometimes referred as “The Standard Streams”
●
The IO access example could be
– stdin Keyboard, pipes→
– stdout Console, Files, Pipes→
– stderr Console, Files, Pipes→

Advanced C
Standard I/O – The File Descriptors
●
Wait!!, did we see something wrong in previous slide?
Both stdout and stderr are similar ?
●
If yes why should we have 2 different streams?
●
The answer is convenience and urgency.
– Convenience : Diagnostic information can be printed
on stderr. Example - we can separate error messages
from low priority informative messages
– Urgency : serious error messages shall be displayed on
the screen immediately
●
So how the C language help us in the standard IO?

Advanced C
Standard I/O – The header file
●
You need to refer input/output library function
#include <stdio.h>
●
When the reference is made with “<name>” the search
for the files happen in standard path
●
Header file Vs Library

Advanced C
Standard I/O – Unformatted (Basic)
●
Internal binary representation of the data directly between
memory and the file
●
Basic form of I/O, simple, efficient and compact
●
Unformatted I/O is not directly human readable, so you
cannot type it out on a terminal screen or edit it with a text
editor
●
getchar() and putchar() are two functions part of standard C
library
●
Some functions like getch(), getche(), putch() are defined in
conio.h, which is not a standard C library header and is not
supported by the compilers targeting Linux / Unix systems

Advanced C
#include <stdio.h>
#include <ctype.h>
int main()
{
int ch;
for ( ; (ch = getchar()) != EOF; )
{
putchar(toupper(ch));
}
puts(“EOF Received”);
return 0;
}
001_example.c

Advanced C
#include <stdio.h>
#include <ctype.h>
int main()
{
int ch;
for ( ; (ch = getc(stdin)) != EOF; )
{
putc(toupper(ch), stdout);
}
puts(“EOF Received”);
return 0;
}
002_example.c

Advanced C
#include <stdio.h>
int main()
{
char str[10];
puts(“Enter the string”);
gets(str);
puts(str);
return 0;
}
003_example.c

Advanced C
#include <stdio.h>
#include <ctype.h>
int main()
{
char str[10];
puts(“Enter the string”);
fgets(str, 10, stdin);
puts(str);
return 0;
}
004_example.c

Advanced C
Standard I/O – Formatted
●
Data is formatted or transformed
●
Converts the internal binary representation of the data to
ASCII before being stored, manipulated or output
●
Portable and human readable, but expensive because of
the conversions to be done in between input and output
●
The printf() and scanf() functions are examples of
formatted output and input

Advanced C
Standard I/O – printf()
●
What will be the output of
the code on left side?
●
Is that syntactically OK?
●
Lets understand the
printf() prototype
●
Please type
man printf
on your terminal
#include <stdio.h>
int main()
{
char a[8] = “Emertxe”;
printf(a);
return 0;
}
005_example.c

Advanced C
●
Converts, formats, and prints its arguments on the
standard output under control of the format
●
Returns the number of characters printed
Prototype
int printf(const char *format, ...);
or
int printf(“format string”, [variables]);
where format string arguments can be
%[flags][width][.precision][length]type_specifier
%type_specifier is mandatory and others are optional

Advanced C
Prototype
What is this!?

Advanced C
●
Is called as ellipses
●
Means, you can pass any number (i.e 0 or more) of
“optional” arguments of any type
●
So how to complete the below example?
Prototype
What is this!?
Example
int printf(“%c %d %f”, );
What should be written here and how many?

Advanced C
●
So the number of arguments passed to the printf function
should exactly match the number of format specifiers
●
So lets go back the code again
int printf(“%c %d %f”, arg1, arg2, arg3);
Now, how to you decide this!?
Based on the number of format specifiers
Example

Advanced C
#include <stdio.h>
int main()
{
char a[8] = “Emertxe”;
printf(a);
return 0;
}
Isn't this a string?
And strings are nothing but array of characters
terminated by null
So what get passed, while passing a array
to function?
Isn't this a pointer?
So a pointer hold a address, can be drawn as
0x10000x2000format
So the base address of the array gets passed to the pointer, Hence the output
Note: You will get a warning while compiling the above code.
So this method of passing is not recommended
E m e r t x e 0
0x1000
a
Example

Advanced C
Standard I/O – printf() - Type Specifiers
Specifiers Example Expected Output
%c printf(“%c”, 'A') A
%d %i printf(“%d %i”, 10, 10) 10 10
%o printf(“%o”, 8) 10
%x %X printf(“%x %X %x”, 0xA, 0xA, 10) a A a
%u printf(“%u”, 255) 255
%f %F printf(“%f %F”, 2.0, 2.0) 2.000000 2.000000
%e %E printf(“%e %E”, 1.2, 1.2) 1.200000e+00 1.200000E+00
%a %A printf(“%a”, 123.4)
printf(“%A”, 123.4)
0x1.ed9999999999ap+6
0X1.ED9999999999AP+6
%g %G printf(“%g %G”, 1.21, 1.0) 1.21 1
%s printf(“%s”, “Hello”) Hello
006_example.c

Advanced C
Standard I/O – printf() - Type Length Specifiers
Length specifier Example Example
%[h]X printf(“%hX”, 0xFFFFFFFF) FFFF
%[l]X printf(“%lX”, 0xFFFFFFFFl) FFFFFFFF
%[ll]X printf(“%llX”, 0xFFFFFFFFFFFFFFFF) FFFFFFFFFFFFFFF
%[L]f printf(“%Lf”,1.23456789L) 1.234568
007_example.c

Advanced C
Standard I/O – printf() - Width
Width Example Expected Output
%[x]d printf(“%3d %3d”, 1, 1)
printf(“%3d %3d”, 10, 10)
printf(“%3d %3d”, 100, 100)
1 1
10 10
100 100
%[x]s printf(“%10s”, “Hello”)
printf(“%20s”, “Hello”)
Hello
Hello
%*[specifier] printf(“%*d”, 1, 1)
printf(“%*d”, 2, 1)
printf(“%*d”, 3, 1)
1
1
1
008_example.c

Advanced C
Standard I/O – printf() - Precision
Precision Example Expected Output
%[x].[x]d printf(“%3.1d”, 1)
printf(“%3.2d”, 1)
printf(“%3.3d”, 1)
1
01
001
%0.[x]f printf(“%0.3f”, 1.0)
printf(“%0.10f”, 1.0)
1.000
1.0000000000
%[x].[x]s printf(“%12.8s”, “Hello World”) Hello Wo
009_example.c

Advanced C
Standard I/O – printf() - Flags
Flag Example Expected Output
%[#]x printf(“%#x %#X %#x”, 0xA, 0xA, 10)
printf(“%#o”, 8)
0xa 0XA 0xa
010
%[-x]d printf(“%-3d %-3d”, 1, 1)
printf(“%-3d %-3d”, 10, 10)
printf(“%-3d %-3d”, 100, 100)
1 1
10 10
100 100
%[ ]3d printf(“% 3d”, 100)
printf(“% 3d”, -100)
100
-100
010_example.c

Advanced C
Standard I/O – printf() - Escape Sequence
Escape
Sequence
Meaning Example Expected Output
n New Line printf(“Hello Worldn”) Hello World (With a new line)
r Carriage
Return
printf(“HellorWorld”) World
t Tab printf(“HellotWorld”) Hello World
b Backspace printf(“HellobWorld”) HellWorld
v Vertical Tab printf(“HellovWorld”) Hello
World
f Form Feed printf(“Hello Worldf”) Might get few extra new line(s)
e Escape printf(“HelloeWorld”) Helloorld
printf(“ABC”) ABC
” printf(““Hello World””) “Hello World”
011_example.c

Advanced C
●
So in the previous slides we saw some 80% of printf's
format string usage.
What?? Ooh man!!. Now how to print 80%??

Advanced C
Standard I/O – printf() - Example
#include <stdio.h>
int main()
{
int num1 = 123;
char ch = 'A';
float num2 = 12.345;
char string[] = “Hello World”;
printf(“%d %c %f %sn”,num1 , ch, num2, string);
printf(“%+05dn”, num1);
printf(“%.2f %.5sn”, num2, string);
return 0;
}
012_example.c

Advanced C
Standard I/O – printf() - Return
#include <stdio.h>
int main()
{
int ret;
char string[] = “Hello World”;
ret = printf(“%sn”, string);
printf(“The previous printf() printed %d charsn”, ret);
return 0;
}
013_example.c

Advanced C
Standard I/O – sprintf() - Printing to string
Prototype
int sprintf(char *str, const char *format, ...);
●
Similar to printf() but prints to the buffer instead of
stdout
●
Formats the arguments in arg1, arg2, etc., according to
format specifier
●
buffer must be big enough to receive the result

Advanced C
Standard I/O – sprintf() - Example
#include <stdio.h>
int main()
{
int num1 = 123;
char ch = 'A';
float num2 = 12.345;
char string1[] = “sprintf() Test”;
char string2[100];
sprintf(string2, “%d %c %f %sn”,num1 , ch, num2, string1);
printf(“%s”, string2);
return 0;
}
014_example.c

Advanced C
Standard I/O – Formatted Input - scanf()
●
Reads characters from the standard input, interprets
them according to the format specifier, and stores the
results through the remaining arguments.
●
Almost all the format specifiers are similar to printf()
except changes in few
●
Each “optional” argument must be a pointer
Prototype
int scanf(char *format, ...);
or
int scanf(“string”, [variables]);

Advanced C
Standard I/O – Formatted Input - scanf()
●
It returns as its value the number of successfully matched
and assigned input items.
●
On the end of file, EOF is returned. Note that this is
different from 0, which means that the next input
character does not match the first specification in the
format string.
●
The next call to scanf() resumes searching immediately
after the last character already converted.

Advanced C
Standard I/O – scanf() - Example
#include <stdio.h>
int main()
{
int num1;
char ch;
float num2;
char string[10];
scanf(“%d %c %f %s”, &num1 , &ch, &num2, string);
printf(“%d %c %f %sn”, num1 , ch, num2, string);
return 0;
}
015_example.c

Advanced C
Standard I/O – scanf() - Format Specifier
Flag Examples Expected Output
%*[specifier] scanf(“%d%*c%d%*c%d”, &h, &m, &s) User Input HH:MM:SS→
Scanned Input HHMMSS→
User Input 5+4+3→
Scanned Input 543→
016_example.c

Advanced C
Standard I/O – scanf() - Format Specifier
Flag Examples Expected Output
%[] scanf(“%[a-z A-Z]”, name)
scanf(“%[0-9]”, id)
User Input Emertxe→
Scanned Input Emertxe→
User Input Emx123→
Scanned Input Emx→
User Input 123→
User Input 123XYZ→
017_example.c

Advanced C
Standard I/O – scanf() - Return
#include <stdio.h>
int main()
{
int num = 100, ret;
printf(“The enter a number [is 100 now]: ”);
ret = scanf(“%d”, &num);
if (ret != 1)
{
printf(“Invalid input. The number is still %dn”, num);
return 1;
}
else
{
printf(“Number is modified with %dn”, num);
}
return 0;
}
018_example.c

Advanced C
Standard I/O – sscanf() - Reading from string
Prototype
int sscanf(const char *string, const char *format, ...);
●
Similar to scanf() but read from string instead of stdin
●
Formats the arguments in arg1, arg2, etc., according to
format

Advanced C
Standard I/O – sscanf() - Example
#include <stdio.h>
int main()
{
int age;
char array_1[10];
char array_2[10];
sscanf(“I am 30 years old”, “%s %s %d”, array_1, array_2, &age);
sscanf(“I am 30 years old”, “%*s %*s %d”, &age);
printf(“OK you are %d years oldn”, age);
return 0;
}
019_example.c

Advanced C
Standard I/O – DIY
user@user:~]
user@user:~]./print_bill.out
Enter the item 1: Kurkure
Enter no of pcs: 2
Enter the cost : 5
Enter the item 2: Everest Paneer Masala
Enter no of pcs: 1
Enter the item 3: India Gate Basmati
Enter no of pcs: 1
--------------------------------------------------------------------------
S.No Name Quantity Cost Amount
--------------------------------------------------------------------------
1. Kurkure 2 5.00          10.00
2. Everest Paneer 1          25.50 25.50
3. India Gate Bas 1          1050.00 1050.00
--------------------------------------------------------------------------
Total          4 1085.50
--------------------------------------------------------------------------
user@user:~]
Screen Shot

Advanced C
Standard I/O – DIY
user@user:~]
user@user:~]./progress_bar.out
Loading [----------------------------------------------------------------------] 50%
user@user:~]
Screen Shot

Advanced C
Standard I/O – Buffering
CPU
RAM
Output
Buffer
Input
Buffer

Advanced C
Standard I/O – Buffering
P1
User Space
Kernel Space
fwrite() fread()
write() read()
Buffer
Buffer

Advanced C
Standard I/O – User Space Buffering
●
Refers to the technique of temporarily storing the
results of an I/O operation in user-space before
transmitting it to the kernel (in the case of writes) or
before providing it to your process (in the case of
reads)
●
This technique minimizes the number of system calls
(between user and kernel space) which may improve
the performance of your application

Advanced C
Standard I/O – User Space Buffering
●
For example, consider a process that writes one
character at a time to a file. This is obviously
inefficient: Each write operation corresponds to a
write() system call
●
Similarly, imagine a process that reads one character
at a time from a file into memory!! This leads to
read() system call
●
I/O buffers are temporary memory area(s) to
moderate the number of transfers in/out of memory
by assembling data into batches

Advanced C
Standard I/O – Buffering - stdout
●
The output buffer get flushed out due to the following
reasons
– Normal Program Termination
– 'n' in a printf
– Read
– fflush call
– Buffer Full

Advanced C
#include <stdio.h>
int main()
{
printf(“Hello”);
return 0;
}
020_example.c

Advanced C
#include <stdio.h>
#include <unistd.h>
int main()
{
while (1)
{
sleep(1);
}
return 0;
}
#include <stdio.h>
#include <unistd.h>
int main()
{
while (1)
{
printf(“Hellon”);
sleep(1);
}
return 0;
}
Solution021_example.c

Advanced C
#include <stdio.h>
#include <unistd.h>
int main()
{
int num;
while (1)
{
printf(“Enter a number: ”);
scanf(“%d”, &num);
}
return 0;
}
022_example.c

Advanced C
#include <stdio.h>
#include <unistd.h>
int main()
{
while (1)
{
fflush(stdout);
sleep(1);
}
return 0;
}
023_example.c

Advanced C
#include <stdio.h>
#include <unistd.h>
int main()
{
char str[BUFSIZ] = “1”;
while (1)
{
printf(“%s”, str);
sleep(1);
}
return 0;
}
#include <stdio.h>
#include <unistd.h>
int main()
{
char str[BUFSIZ] = “1”;
setbuf(stdout, NULL);
while (1)
{
printf(“%s”, str);
sleep(1);
}
return 0;
}
Solution024_example.c

Advanced C
Standard I/O – Buffering - stdin
●
The input buffer generally gets filled till the user presses
and enter key of end of file.
●
The complete buffer would be read till a 'n' or and EOF is
received.

Advanced C
#include <stdio.h>
int main()
{
char ch = 'y';
printf(“Enter a string: ”);
while (ch != 'n')
{
scanf(“%c”, &ch);
printf(“%c”, ch);
}
return 0;
}
025_example.c

Advanced C
#include <stdio.h>
int main()
{
char ch = 'y';
while (ch != 'n')
{
__fpurge(stdin);
}
return 0;
}
Solution 1
#include <stdio.h>
int main()
{
char ch = 'y';
while (ch != 'n')
{
while (getchar() != 'n');
}
return 0;
}
Solution 2

Advanced C
Standard I/O – Buffering - stderr
●
The stderr file stream is unbuffered.
#include <stdio.h>
#include <unistd.h>
int main()
{
while (1)
{
fprintf(stdout, “Hello”);
fprintf(stderr, “World”);
sleep(1);
}
return 0;
}
026_example.c

Advanced C
S_____s – Fill in the blanks please ;)
`

Advanced C
Strings
`
A set of things tied or threaded together on a thin cord
Source: Google
String of Beads
Bead
String
Start of String
String ends hereContains n numbers of Beads

Advanced C
Strings
●
Contiguous sequence of characters
●
Stores printable ASCII characters and its extensions
●
End of the string is marked with a special character, the
null character '0'
●
'0' is implicit in strings enclosed with “”
●
Example
“You know, now this is what a string is!”

Advanced C
Strings
●
Constant string
– Also known as string literal
– Such strings are read only
– Usually, stored in read only (code or text segment) area
– String literals are shared
●
Modifiable String
– Strings that can be modified at run time
– Usually, such strings are stored in modifiable memory
area (data segment, stack or heap)
– Such strings are not shared

Advanced C
Strings - Initialization
char char_array[5] = {'H', 'E', 'L', 'L', 'O'}; Character Array
char str1[6] = {'H', 'E', 'L', 'L', 'O', '0'}; String
char str3[6] = {“H”, “E”, “L”, “L”, “O”}; Invalid
char str4[6] = {“H” “E” “L” “L” “O”}; Valid
char str2[] = {'H', 'E', 'L', 'L', 'O', '0'}; Valid
char str5[6] = {“HELLO”}; Valid
char str6[6] = “HELLO”; Valid
char str7[] = “HELLO”; Valid
char *str8 = “HELLO”; Valid
001_example.c

Advanced C
Strings – Memory Allocation
char str1[] = {'H', 'E', 'L', 'L', 'O', '0'};
‘H’
‘E’
‘L’
‘L’
‘O’
‘0’
1000
1001
1002
1003
1004
1005
str1
char *str2 = “Hello”;
‘H’
‘E’
‘L’
‘L’
‘O’
‘0’
1000
1001
1002
1003
1004
1005
str2
? 998
? 997
1000 996
? 999
Example

Advanced C
Strings - Size
#include <stdio.h>
int main()
{
char char_array_1[5] = {'H', 'E', 'L', 'L', 'O'};
char char_array_2[] = “Hello”;
sizeof(char_array_1);
sizeof(char_array_2);
return 0;
}
The size of the array
is calculated so,
5, 6
int main()
{
char *str = “Hello”;
sizeof(str);
return 0;
}
The size of pointer
is always constant
so,
4 (32 Bit Sys)
002_example.c
003_example.c

Advanced C
Strings - Size
#include <stdio.h>
int main()
{
if (sizeof(“Hello” “World”) == sizeof(“Hello”) + sizeof(“World”))
{
printf(“WoWn”);
}
else
{
printf(“HuHn”);
}
return 0;
}
004_example.c

Advanced C
Strings - Manipulations
#include <stdio.h>
int main()
{
char str1[6] = “Hello”;
char str2[6];
str2 = “World”;
char *str4;
str4 = “World”;
str1[0] = 'h';
str3[0] = 'w';
printf(“%sn”, str1);
printf(“%sn”, str2);
return 0;
}
Not possible to assign a string to a
array since its a constant pointer
Possible to assign a string to
a pointer since its variable
Valid. str1 contains “hello”
Invalid. str3 might be stored in
read only section.
Undefined behaviour
005_example.c

Advanced C
Strings - Sharing
#include <stdio.h>
int main()
{
if (str1 == str2)
{
printf(“Hoo. They share same spacen”);
}
else
{
printf(“No. They are in different spacen”);
}
return 0;
}
006_example.c

Advanced C
Strings - Sharing
‘H’
‘E’
‘L’
‘L’
‘O’
‘0’
100
101
102
103
104
105
str1
? 998
? 801
100 800
? 999
? 997
100 996
str2
●
●
●

Advanced C
Strings – Empty String
#include <stdio.h>
#include <string.h>
int main()
{
char *str = “”;
int ret;
ret = strlen(str);
printf(“%dn”, ret);
return 0;
}
007_example.c

Advanced C
Strings – Passing to Function
#include <stdio.h>
void print(const char *str)
{
while (*str)
{
putchar(*str++);
}
}
int main()
{
char *str = “Hello World”;
print(str);
return 0;
}
008_example.c

Advanced C
Strings - Reading
#include <stdio.h>
int main()
{
char str[6];
gets(str);
printf(“The string is: %sn”, str);
return 0;
}
●
The above method is not recommend by the gcc. Will
issue warning while compilation
●
Might lead to stack smashing if the input length is greater
than array size!!
009_example.c

Advanced C
Strings - Reading
#include <stdio.h>
int main()
{
char str[6];
fgets(str, 6, stdin);
scanf(“%5[^n], str);
return 0;
}
●
fgets() function or selective scan with width are
recommended to read string from the user
010_example.c

Advanced C
Strings – DIY
●
WAP to calculate length of the string
●
WAP to copy a string
●
WAP to compare two strings
●
WAP to compare two strings ignoring case
●
WAP to check a given string is palindrome or not

Advanced C
Strings – Library Functions
Purpose Prototype Return Values
Length size_t strlen(const char *str) String Length
Compare int strcmp(const char *str1, const char *str2) str1 < str2 < 0→
str1 > str2 > 0→
str1 = str2 = 0→
Copy char *strcpy(char *dest, const char *src) Pointer to dest
Check
String
char *strstr(const char *haystack, const char *needle) Pointer to the
beginning of
substring
Check
Character
char *strchr(const char *s, int c) Pointer to the
matched char else
NULL
Merge char *strcat(char *dest, const char *src) Pointer to dest

Advanced C
Strings – Quiz
●
Can we copy 2 strings like, str1 = str2?
●
Why don't we pass the size of the string to string
functions?
●
What will happen if you overwrite the '0' (null character)
of string? Will you still call it a string?
●
What is the difference between char *s and char s[]?

Advanced C
Strings – Quiz – Pointer vs Array
Pointer Array
A single variable designed to store
address
A bunch of variables; Each variable is
accessed through index number
Size of pointer depends on size of
address (Ex - 32 bit or 64 bit)
Size of Array depends on number of
elements and their type
Pointer is a lvalue -
●
Pointers can be modified (can be
incremented/decremented or new
addresses can be stored)
Array name is not lvalue -
●
Array name represents either whole
array (when operand to sizeof
operator) or base address (address of
first element in the array)
●
Can’t be modified (Array can’t be
incremented/decremented or base
address can’t be changed)

Advanced C
Strings – DIY
●
WAP to reverse a string
●
WAP to compare string2 with string1 up to n characters
●
WAP to concatenate two strings

Advanced C
Strings – DIY
●
Use the standard string functions like
– strlen
– strcpy
– strcmp
– strcat
– strstr
– strtok

Advanced C
Strings – DIY
●
WAP to print user information –
– Read : Name, Age, ID, Mobile number
– Print the information on monitor
– Print error “Invalid Mobile Number” if length of mobile
number is not 10
●
WAP to read user name and password and compare with
stored fields. Present a puzzle to fill in the banks
●
Use strtok to separate words from string
“www.emertxe.com/bangalore”

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

Advanced C
Memory Segments
Linux OS
P1
User
Space
Kernel
Space
The Linux OS is divided into two major sections
●
User Space
●
Kernel Space
The user programs cannot access the kernel
space. If done will lead to segmentation
violation
Let us concentrate on the user space section
here

Advanced C
Memory Segments
Linux OS
P1
User
Space
Kernel
Space
P1
P2
P3
.
.
.
P1
Pn-1
Pn
User Space
The User space contains
many processes
Every process will be
scheduled by the kernel
Each process will have its
memory layout discussed
in next slide

Advanced C
Memory Segments
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
P1
P2
P3
.
.
.
P1
Pn-1
Pn
User Space
The memory segment of a
program contains four
major areas.
●
Text Segment
●
Stack
●
Data Segment
●
Heap

Advanced C
Memory Segments – Text Segment
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
Also referred as Code Segment
Holds one of the section of program in
object file or memory
In memory, this is place below the heap or
stack to prevent getting over written
Is a read only section and size is fixed

Advanced C
Memory Segments – Data Segment
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
Contains 2 sections as initialized and
uninitialized data segments
Initialized section is generally called as Data
Segment
Uninitialized section is referred as BSS
(Block Started by Symbol) usually filled
with 0s

Advanced C
Memory Segments – Data Segment
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
Dynamic memory allocation takes place here
Begins at the end of BSS and grows
upward from there

Advanced C
Memory Segments – Stack Segment
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Memory Segments
Adjoins the heap area and grow in opposite
area of heap when stack and heap pointer
meet (Memory Exhausted)
Typically loaded at the higher part of memory
A “stack pointer” register tracks the top
of the stack; it is adjusted each time
a value is “pushed” onto the stack
Typically loaded at the higher part of memoryTypically loaded at the higher part of
memory
The set of values pushed for one function
call is termed a “stack frame”

Advanced C
Memory Segments – Stack Segment
Stack
Text Segment
Initialized
Heap
.BSS
(Uninitialized)
Command Line
Arguments
Hole
Data
Segment
Local Variables
Return Address
Parameter List
Memory Segments Stack Frame
A stack frame contain at least
of a return address

Advanced C
Memory Segments – Stack Frame
#include <stdio.h>
int main()
{
int num1 = 10, num2 = 20;
int sum = 0;
return 0;
}
int add_numbers(int n1, int n2)
{
int s = 0;
s = n1 + n2;
return s;
}
num1 = 10
num2 = 20
sum = 0
Return Address to the caller
Stack Frame
main()
s = 0
add_numbers()Return Address to the main()
n1 = 10
n2 = 20

Advanced C
Memory Segments - Runtime
●
Text Segment: The text segment contains the actual code to
be executed. It's usually sharable, so multiple instances of a
program can share the text segment to lower memory
requirements. This segment is usually marked read-only so a
program can't modify its own instructions
●
Initialized Data Segment: This segment contains global
variables which are initialized by the programmer
●
Uninitialized Data Segment: Also named “BSS" (block started
by symbol) which was an operator used by an old assembler.
This segment contains uninitialized global variables. All
variables in this segment are initialized to 0 or NULL (for
pointers) before the program begins to execute

Advanced C
Memory Segments - Runtime
●
The Stack: The stack is a collection of stack frames. When a
new frame needs to be added (as a result of a newly called
function), the stack grows downward
●
The Heap: Most dynamic memory, whether requested via C's
malloc() . The C library also gets dynamic memory for its own
personal workspace from the heap as well. As more memory is
requested "on the fly", the heap grows upward

Advanced C
Storage Classes
Variable
Storage
Class
Scope Lifetime
Memory
Allocation
Linkage
Local
auto Block B/W block entry and exit Stack None
register Block B/W block entry and exit
Register /
Stack
None
static Block B/W program start & end Data Segment None
Global
static File B/W program start & end Data segment Internal
extern Program B/W program start & end Data segment
Internal /
External
Function
Parameter
register Function Function entry and exit Stack None
*Block : function body or smaller block with in function

Advanced C
Declaration
extern int num1;
extern int num1;
int main();
int main()
{
int num1, num2;
char short_opt;
...
}
Declaration specifies type to the
variables
Its like an announcement and hence
can be made 1 or more times
Declaration about num1
Declaration about main function
Declaration about num1 yet again!!

Advanced C
Declaration
extern int num1;
extern int num1;
int main();
int main()
{
int num1, num2;
char short_opt;
...
}
Declaration specifies type to the
variables
Its like an announcement and hence
can be made 1 or more times
Declaration about num1
Declaration about main function
Declaration about num1 yet again!!
*** One Definition Rule for variables ***
“In a given scope, there can be only one definition of a variable”

Advanced C
Storage Classes - Auto
#include <stdio.h>
int main()
{
int i = 0;
printf(“i %dn”, i);
return 0;
}
001_example.c

Advanced C
#include <stdio.h>
int foo()
{
int i = 0;
return 0;
}
int main()
{
foo();
return 0;
}
002_example.c

Advanced C
#include <stdio.h>
int *foo()
{
int i = 10;
int *j = &i;
return j;
}
int main()
{
int *i;
i = foo();
printf(“*i %dn”, *i);
return 0;
}
003_example.c

Advanced C
#include <stdio.h>
char *foo()
{
char ca[12] = “Hello World”;
return ca;
}
int main()
{
char *ca;
ca = foo();
printf(“ca is %sn”, ca);
return 0;
}
004_example.c

Advanced C
#include <stdio.h>
int book_ticket()
{
int ticket_sold = 0;
ticket_sold++;
return ticket_sold;
}
int main()
{
int count;
count = book_ticket();
printf(“Sold %dn”, count);
return 0;
}
005_example.c

Advanced C
#include <stdio.h>
int main()
{
int i = 0;
{
int j = 0;
}
printf(“j %dn”, j);
return 0;
}
006_example.c

Advanced C
#include <stdio.h>
int main()
{
int j = 10;
{
int j = 0;
}
return 0;
}
007_example.c

Advanced C
#include <stdio.h>
int main()
{
int i = 10;
int i = 20;
{
}
return 0;
}
008_example.c

Advanced C
Storage Classes - Register
#include <stdio.h>
int main()
{
register int i = 0;
scanf(“%d”, &i);
return 0;
}
009_example.c

Advanced C
#include <stdio.h>
int main()
{
register int i = 10;
register int *j = &i;
printf(“*j %dn”, *j);
return 0;
}
010_example.c

Advanced C
#include <stdio.h>
int main()
{
int i = 10;
register int *j = &i;
printf(“*j %dn”, *j);
return 0;
}
011_example.c

Advanced C
Storage Classes – Static Local
#include <stdio.h>
int *foo()
{
static int i = 10;
int *j = &i;
return j;
}
int main()
{
int *i;
i = foo();
return 0;
}
012_example.c

Advanced C
#include <stdio.h>
char *foo()
{
static char ca[12] = “Hello World”;
return ca;
}
int main()
{
char *ca;
ca = foo();
printf(“ca is %sn”, ca);
return 0;
}
013_example.c

Advanced C
#include <stdio.h>
int book_ticket()
{
static int ticket_sold = 0;
ticket_sold++;
return ticket_sold;
}
int main()
{
int count;
printf(“Sold %dn”, count);
return 0;
}
014_example.c

Advanced C
#include <stdio.h>
int main()
{
static int i = 5;
if (--i)
{
main();
}
return 0;
}
015_example.c
#include <stdio.h>
int main()
{
static int i = 5;
if (--i)
{
return main();
}
return 0;
}
016_example.c

Advanced C
#include <stdio.h>
int foo()
{
static int i;
return i;
}
int main()
{
static int x = foo();
printf(“x %dn”, x);
return 0;
}
017_example.c

Advanced C
#include <stdio.h>
int *foo()
{
static int i = 10;
int *j = &i;
return j;
}
int main()
{
int *i;
i = foo();
return 0;
}
018_example.c

Advanced C
#include <stdio.h>
int *foo()
{
int i = 10;
static int *j = &i;
return j;
}
int main()
{
int *i;
i = foo();
return 0;
}
019_example.c

Advanced C
Storage Classes – Global
#include <stdio.h>
int x;
int foo()
{
return ++x;
}
int main()
{
foo();
return 0;
}
020_example.c

Advanced C
#include <stdio.h>
auto int x;
int foo()
{
return ++x;
}
int main()
{
foo();
return 0;
}
021_example.c

Advanced C
#include <stdio.h>
register int x;
int foo()
{
return ++x;
}
int main()
{
foo();
return 0;
}
022_example.c

Advanced C
#include <stdio.h>
int x = 10;
int foo()
{
return 0;
}
int main()
{
foo();
return 0;
}
023_example.c

Advanced C
●
Will there be any compilation
error?
#include <stdio.h>
int x = 10;
int x;
int foo()
{
return 0;
}
int main()
{
foo();
return 0;
}
024_example.c

Advanced C
●
Will there be any compilation
error?
#include <stdio.h>
int x = 10;
int x = 20;
int foo()
{
return 0;
}
int main()
{
foo();
return 0;
}
025_example.c

Advanced C
#include <stdio.h>
1 int x = 10; // Definition
2 int x; // Tentative definition
3 extern int x; // not a definition either
4 extern int x = 20; // Definition
5 static int x; // Tentative definition
Example
●
Declaration Vs definition
– All the above are declarations
– Definitions as mentioned in the comment

Advanced C
●
Complying with one definition rule
– All the tentative definitions and extern declarations are
eliminated and mapped to definition by linking method
– If there exists only tentative definitions then all of them
are eliminated except one tentative definition which is
changed to definition by assigning zero to the variable
●
Compilation error if there are more then one definitions
●
Compilation error if no definition or tentative definition exists

Advanced C
●
Translation unit – A source file + header file(s) forms a translation
unit
●
Compiler translates source code file written in ‘C’ language to
machine language
●
A program is constituted by the set of translation units and
libraries
●
An identifier may be declared in a scope but used in different
scopes (within a translation unit or in other translation units or
libraries)
●
Linkage – An identifier declared in different scopes or in the same
scope more than once can be made to refer to the same object or
function by a process called linkage
●
There are three type of linkages – internal, external and none

Advanced C
●
External Linkage – A global variable declared without storage class has
“external” linkage
●
Internal Linkage – A global variable declared with static storage class
has “internal” linkage
●
None Linkage – Local variables have “none” linkage
●
Variable declaration with “extern” – in such case, linkage to be
determined by referring to “previous visible declaration”
– If there is no “previous visible declaration” then external linkage
– If “previous visible declaration” is local variable then external
linkage
– If “previous visible declaration” is global variable then linkage is
same as of global variable
“Compilation error if there is linkage disagreement among
definition and tentative definitions”

Advanced C
Storage Classes – Static Global
#include <stdio.h>
static int x = 10;
int foo()
{
return 0;
}
int main()
{
foo();
return 0;
}
026_example.c

Advanced C
Storage Classes – Static Global
#include <stdio.h>
static int x = 10;
int x;
int foo()
{
return 0;
}
int main()
{
foo();
return 0;
}
027_example.c

Advanced C
Storage Classes – External
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
func_2();
sleep(1);
}
return 0;
}
028_file1.c
#include <stdio.h>
extern int num;
int func_1()
{
printf(“num is %d from file2n”, num);
return 0;
}
#include <stdio.h>
extern int num;
int func_2()
{
return 0;
}
029_file2.c
030_file3.c

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
#include <stdio.h>
extern int num;
extern int num;
int func_1()
{
return 0;
}
031_file1.c
032_file2.c

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
#include <stdio.h>
static int num;
extern int num;
int func_1()
{
return 0;
}
033_file1.c
034_file2.c

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
#include <stdio.h>
extern char num;
int func_1()
{
return 0;
}
035_file1.c
036_file2.c

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
#include <stdio.h>
extern int num;
extern char num;
int func_1()
{
return 0;
}
037_file1.c
038_file2.c
Conflicting types

Advanced C
#include <stdio.h>
int main()
{
int x;
{
int x = 10;
{
extern int x;
}
}
return 0;
}
int x = 20;
039_example.c

Advanced C
#include <stdio.h>
int main()
{
extern char x;
printf(“x %cn”, x);
return 0;
}
int x = 0x31;
040_example.c

Advanced C
Invalid, extern and initializer
not permitted in block scope
#include <stdio.h>
int main()
{
int x;
{
int x = 10;
{
extern int x = 20;
}
}
return 0;
}
int x;
041_example.c

Advanced C
Storage Classes – Static Function
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
}
return 0;
}
#include <stdio.h>
extern int num;
static int func_2()
{
return 0;
}
int func_1()
{
func_2();
}
042_file1.c
043_file2.c

Advanced C
Storage Classes – Static Function
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_2();
}
return 0;
}
#include <stdio.h>
extern int num;
static int func_2()
{
return 0;
}
int func_1()
{
func_2();
}
044_file1.c
045_file2.c

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
file1.c
#include <stdio.h>
extern int num;
static int num;
int func_1()
{
return 0;
}
file2.c
●
Compiler error due to linkage disagreement

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
file1.c
#include <stdio.h>
int num;
static int num;
int func_1()
{
return 0;
}
file2.c
●

Advanced C
#include <stdio.h>
int num;
int main()
{
while (1)
{
num++;
func_1();
sleep(1);
}
return 0;
}
file1.c
#include <stdio.h>
static int num;
int num;
int func_1()
{
return 0;
}
file2.c
●

Advanced C
#include <stdio.h>
int main()
{
int x;
{
int x = 10;
{
extern int x;
}
}
return 0;
}
static int x = 20;
Example
●
Compiler error due to linkage
disagreement

Advanced C
#include <stdio.h>
static int x = 20;
int main()
{
int x;
{
int x = 10;
{
extern int x;
}
}
return 0;
}
Example
●
Compiler error due to linkage
disagreement

Advanced C
#include <stdio.h>
int x = 20;
int main()
{
int x;
{
int x = 10;
{
extern int x;
}
}
return 0;
}
Example
●
Should be a fine since the
compiler refers the same
variable x and prints 20

Advanced C - Part 2

More Related Content

What's hot (20)

Similar to Advanced C - Part 2 (20)

More from Emertxe Information Technologies Pvt Ltd (20)

Recently uploaded (20)

Advanced C - Part 2