1. C Basics for Data Structures Bridge Course

C Basics for Data Structures
Bridge Course
(27.07.2020 – 31.07.2020)
Dr. P. Subathra
Professor
Dept. of Information Technology
KAMARAJ College of Engineering and Technology
Madurai
Tamil Nadu
India
subathrakishore@yahoo.com
8/14/2020

Topics
• Arrays
• Pointers
• Structures
8/14/2020
Functions

Arrays
1. What is an Array?
2. How is it stored in the Memory?
3. Why isn’t there any boundary for an Array?
4. How is a program allocated memory in a system
during compilation and execution?
5. What is a Pointer?
6. What actually is an Array variable?
7. How is Static Memory allocation done for an
Array in C?
8. How is Dynamic Memory allocation done for an
Array in C?
8/14/2020

Arrays - Pointers
1. What is an Array?
2. How is it stored in the Memory?
3. Why isn’t there any boundary for an Array?
4. How is a program allocated memory in a system
during compilation and execution?
5. What is a Pointer?
6. What is a Pointer to a Pointer?
7. What actually is an Array variable?
8. How is Static Memory allocation done for an
Array in C?
9. How is Dynamic Memory allocation done for an
Array in C?
8/14/2020

Introduction
• Arrays
– Structures of related data items
– Static entity - same size throughout program
• A few types
– C-like, pointer-based arrays
– C++, arrays as objects

Arrays
c[6]
-45
6
0
72
1543
-89
0
62
-3
1
6453
78
Name of array (Note that all
elements of this array have
the same name, c)
c[0]
c[1]
c[2]
c[3]
c[11]
c[10]
c[9]
c[8]
c[7]
c[5]
c[4]
Position number of the element
within array c

Declaring Arrays
• Declaring arrays - specify:
– Name
– Type of array
– Number of elements
– Examples
int c[ 10 ];
float hi[ 3284 ];
• Declaring multiple arrays of same type
– Similar format as other variables
– Example
int b[ 100 ], x[ 27 ];

Examples Using Arrays
• Initializers
int n[ 5 ] = { 1, 2, 3, 4, 5 };
– If not enough initializers, rightmost elements become 0
– If too many initializers, a syntax error is generated
int n[ 5 ] = { 0 }
– Sets all the elements to 0
• If size omitted, the initializers determine it
int n[] = { 1, 2, 3, 4, 5 };
– 5 initializers, therefore n is a 5 element array

9
Problem with Arrays
• Sometimes
– Amount of data cannot be predicted beforehand
– Number of data items keeps changing during program
execution
• One solution: find the maximum possible value of N and allocate
an array of N elements
– Wasteful of memory space, as N may be much smaller in some
executions
– Example: maximum value of N may be 10,000, but a particular
run may need to search only among 100 elements
• Using array of size 10,000 always wastes memory in most
cases

10
Better Solution
• Dynamic memory allocation
– Know how much memory is needed after the program is
run
• Example: ask the user to enter from keyboard
– Dynamically allocate only the amount of memory needed
• C provides functions to dynamically allocate memory
– malloc, calloc, realloc

11
Memory Allocation Functions
• malloc
– Allocates requested number of bytes and returns a
pointer to the first byte of the allocated space
• calloc
– Allocates space for an array of elements, initializes
them to zero and then returns a pointer to the memory.
• free
– Frees previously allocated space.
• realloc
– Modifies the size of previously allocated space.

12
Allocating a Block of Memory
• A block of memory can be allocated using the
function malloc
– Reserves a block of memory of specified size and
returns a pointer of type void
– The return pointer can be type-casted to any
pointer type
• General format:
type *p;
p = (type *) malloc (byte_size);

13
Example
p = (int *) malloc(100 * sizeof(int));
– A memory space equivalent to 100 times the
size of an int bytes is reserved
– The address of the first byte of the allocated
memory is assigned to the pointer p of type int
p
400 bytes of space

14
Contd.
• cptr = (char *) malloc (20);
Allocates 20 bytes of space for the pointer cptr of type
char
• sptr = (struct stud *) malloc(10*sizeof(struct stud));
Allocates space for a structure array of 10 elements. sptr
points to a structure element of type struct stud
Always use sizeof operator to find number of bytes for a data type, as
it can vary from machine to machine

15
Points to Note
• malloc always allocates a block of contiguous bytes
– The allocation can fail if sufficient contiguous
memory space is not available
– If it fails, malloc returns NULL
if ((p = (int *) malloc(100 * sizeof(int))) == NULL)
{
printf (“n Memory cannot be allocated”);
exit();
}

16
Releasing the Allocated Space: free
• An allocated block can be returned to the system for
future use by using the free function
• General syntax:
free (ptr);
where ptr is a pointer to a memory block which has
been previously created using malloc
• Note that no size needs to be mentioned for the
allocated block, the system remembers it for each
pointer returned

8/14/2020
P=(int*) malloc(10);
}

Operations not allowed on Pointers
• Addition of two pointers
• Multiplication of Two pointers
• Multiplying a constant to a pointer
• Division of Pointers
• Division of a Pointer by a Constant
8/14/2020

Pointers in 2D Arrays
• Dynamic Allocation done at the HEAP
8/14/2020

68
Pointers to Pointers
• Pointers are also variables (storing addresses), so
they have a memory location, so they also have an
address
• Pointer to pointer – stores the address of a pointer
variable
int x = 10, *p, **q;
p = &x;
q = &p;
printf(“%d %d %d”, x, *p, *(*q));
will print 10 10 10 (since *q = p)

69
Allocating Pointer to Pointer
int **p;
p = (int **) malloc(3 * sizeof(int *));
p
p[2]
p[1]
p[0]
int ** int *
int *
int *

2D array
70
#include <stdlib.h>
int main()
{
int **array;
array = (int**) malloc(nrows * sizeof(int *));
for(i = 0; i < nrows; i++)
{
array[i] = (int*)malloc(ncolumns * sizeof(int));
}
{

Arrays in C CS-2301, B-Term 2009 71
Arrays as Function Parameters
• void init(float A[], int arraySize);
void init(float *A, int arraySize);
• Are identical function prototypes!
• Pointer is passed by value
• I.e. caller copies the value of a pointer to
float into the parameter A
• Called function can reference through that
pointer to reach thing pointed to

Arrays in C CS-2301, B-Term 2009 72
Arrays as Function Parameters (continued)
• void init(float A[], int arraySize){
int n;
for(n = 0; n < arraySize; n++)
A[n] = (float)n;
} //init
• Assigns values to the array A in place
– So that caller can see the changes!

Allocating new heap memory
CS 3090: Safety Critical Programming in C 73
void *malloc(size_t size);
• Allocate a block of size bytes,
return a pointer to the block
(NULL if unable to allocate block)
void *calloc(size_t num_elements,
size_t element_size);
• Allocate a block of num_elements * element_size bytes,
initialize every byte to zero,
return pointer to the block
(NULL if unable to allocate block)
Note: void * denotes a generic pointer type

Allocating new heap memory
void *realloc(void *ptr, size_t new_size);
 Given a previously allocated block starting at ptr,
 change the block size to new_size,
 return pointer to resized block
 If block size is increased, contents of old block may be copied to a
completely different region
 In this case, the pointer returned will be different from the ptr argument,
and ptr will no longer point to a valid memory region
 If ptr is NULL, realloc is identical to malloc
 Note: may need to cast return value of malloc/calloc/realloc:
char *p = (char *) malloc(BUFFER_SIZE);

Deallocating heap memory
void free(void *pointer);
• Given a pointer to previously allocated memory,
– put the region back in the heap of unallocated memory
• Note: easy to forget to free memory when no longer
needed...
– especially if you’re used to a language with “garbage
collection” like Java
– This is the source of the notorious “memory leak” problem
– Difficult to trace – the program will run fine for some time,
until suddenly there is no more memory!

1. C Basics for Data Structures Bridge Course

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to 1. C Basics for Data Structures Bridge Course

Similar to 1. C Basics for Data Structures Bridge Course (20)

More from P. Subathra Kishore, KAMARAJ College of Engineering and Technology, Madurai

More from P. Subathra Kishore, KAMARAJ College of Engineering and Technology, Madurai (20)

Recently uploaded

Recently uploaded (20)

1. C Basics for Data Structures Bridge Course