Scribd
Upload
42 views

Pointers and Arrays: ESC101 October 25

1. Pointers and arrays are interchangeable in C as array names are nothing but pointers. 2. There is a difference between static and dynamic memory allocation - static allocation cannot be reassigned while dynamic uses malloc() and can be reassigned. 3. Realloc() automatically frees old memory if successful, otherwise returns old address.

Uploaded by

Aditya Tiwari
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
42 views

Pointers and Arrays: ESC101 October 25

1. Pointers and arrays are interchangeable in C as array names are nothing but pointers. 2. There is a difference between static and dynamic memory allocation - static allocation cannot be reassigned while dynamic uses malloc() and can be reassigned. 3. Realloc() automatically frees old memory if successful, otherwise returns old address.

Uploaded by

Aditya Tiwari
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 22

Pointers and arrays

ESC101
October 25th
Announcements
• MQ2 copies shown in tutorial next week
• Lab end sem exam on 11th November in NCL (as
before)
– Syllabus: everything
– Logistics: same as before
• Theory end sem exam on 22nd November afternoon
– Details to follow
– Cannot miss this exam
• End sem copies shown on 27th November
– Vacation begins 28th
Recap: dynamic memory allocation
int * ar;
….
ar = (int *) malloc(…); // allocate memory
if (ar == NULL) { // or if (!ar)
// take corrective measures and return failures
}
…ar[i] …
free(ar); // free after last use of ar
Question
• What is the difference between the arr we get
from
– int arr[10]
– int *arr followed by arr = malloc(sizeof(int)*10)
• Both are pointers to the first block of memory
assigned to the array
• Static assigned pointer cannot be re-assigned
• Dynamically assigned pointer can be re-
assigned
Question: realloc and free
• How do we free a pointer we passed into
realloc and returned out into the same
variable name?
– If realloc succeeds in memory allocation, old
memory is automatically freed
– If realloc fails, it returns the old address as the
new address
Arrays and Pointers
• In C, array names are nothing
int ar[10], *b;
but pointers.
– Can be used interchangeably in ar = ar + 2;
most cases
ar = b;
• However, array names can
not be assigned, but pointer b = ar;
variables can be. b = b + 1;
– Array name is not a variable. It
gets evaluated in C. b = ar + 2;
b++;
Aug-19 6 Esc101, Pointers
Precedence (Unary Refined)
( ) [ ] LR

* (deref) ++ -- ! & +- RL

* / % LR

+ - LR

< <= > >= LR

== != LR
&& LR
|| LR
= RL
, LR
Array of Pointers
• Consider the following declaration
int *arr[10];
• arr is a 10-sized array of pointers to integers
• How can we have equivalent dynamic array?

int **arr;
arr = (int **) malloc ( 10 * sizeof(int *) );

Aug-19 8 Esc101, Pointers


Array of Pointers
int **arr;
arr = (int **) malloc ( 10 * sizeof(int *) );
• Note that individual elements in the array arr
(arr[0], … arr[9]) are NOT allocated any space.
Uninitialized.
• We need to do it (directly or indirectly) before
using them.

int j;
for (j = 0; j < 10; j++)
arr[j] = (int*) malloc (sizeof(int));
Aug-19 9 Esc101, Pointers
Subtle difference
• Array of pointers • Pointer to array

int *ptr[10]; int (*ptr)[10];


int a[10]={0,1,2,3,4,5,6,7,8,9}; int a[10]={99,1,2,3,4,5,6,7,8,9};
*ptr=a; ptr=&a;
printf("%d",*ptr[1]); printf("%d",(*ptr)[1]);

Output: Segfault Output: 1


Exercise: All Substrings
• Read a string and create an array containing
all its substrings (i.e. contiguous).
• Display the substrings.
Input: ESC
E
Output: ES
ESC
S
SC
C
Aug-19 11 Esc101, Pointers
All Substrings: Solution Strategy
• What are the possible substrings for a string
having length 𝑙𝑒𝑛?
• For 0 ≤ 𝑖 < 𝑙𝑒𝑛 and for every 𝑖 ≤ 𝑗 < 𝑙𝑒𝑛,
consider the substring between the 𝑖 𝑡ℎ and
𝑗𝑡ℎ index.
• Allocate a 2D char array having
𝑙𝑒𝑛×(𝑙𝑒𝑛+1)
rows (Why ? How many columns?)
2
• Copy the substrings into different rows of this
array.
Aug-19 12 Esc101, Pointers
int len, i, j, k=0, nsubstr;
char st[100], **substrs;

Solution: Version 1
scanf("%s",st);
len = strlen(st);
nsubstr = len*(len+1)/2;
substrs = (char**)malloc(sizeof(char*) * nsubstr);
for (i=0; i<nsubstr; i++)
substrs[i] = (char*)malloc(sizeof(char) * (len+1));

for (i=0; i<len; i++){


for (j=i; j<len; j++){
strncpy(substrs[k], st+i, j-i+1);
k++;
}
} for (i=0; i<k; i++)
for (i=0; i<k; i++) free(substrs[i]);
printf("%s\n",substrs[i]); free(substrs);
Aug-19 13 Esc101, Pointers
Too much wastage…

E ‘\0’
E S ‘\0’
E S C ‘\0’
S ‘\0’
S C ‘\0’
C ‘\0’

Aug-19 14 Esc101, Pointers


int len, i, j, k=0,nsubstr; char st[100], **substrs;
scanf("%s",st);

Solution: Version 2
len = strlen(st);
nsubstr = len*(len+1)/2;
substrs = (char**)malloc(sizeof(char*) * nsubstr);

for (i=0; i<len; i++)


for (j=i; j<len; j++){
substrs[k] = (char*)malloc(sizeof(char) * (j-i+2));
strncpy(substrs[k], st+i, j-i+1);
k++;
}
for (i=0; i<k; i++)
printf("%s\n",substrs[i]); for (i=0; i<k; i++)
free(substrs[i]);
free(substrs);
This version uses much less memory compared to version 1
Aug-19 15 Esc101, Pointers
int len, i, j, k=0,nsubstr;
char st[100], **substrs;

Solution: Version 3
scanf("%s",st);
len = strlen(st);
nsubstr = len*(len+1)/2;
substrs = (char**)malloc(sizeof(char*) * nsubstr);

for (i=0; i<len; i++){


for (j=i; j<len; j++){
substrs[k] = strdup(st+i, j-i+1);
k++;
}
} for (i=0; i<k; i++)
for (i=0; i<k; i++) free(substrs[i]);
printf("%s\n",substrs[i]); free(substrs);
Less code => more readable, fewer bugs!
possibly faster!
Aug-19 16 Esc101, Pointers
Example Function that Returns Pointer

char *strdup(const char *s);


• strdup creates a copy of the string (char array)
passed as arguments
– copy is created in dynamically allocated memory block
of sufficient size
• returns a pointer to the copy created
• C does not allow returning an Array of any type
from a function
– But we can use a pointer to simulate return of an
array (or multiple values of same type)

Aug-19 17 Esc101, Pointers


Returning Pointer: Beware
#include<stdio.h> #include<stdio.h>
int *fun(); int *fun();
int main() { int main() {
printf("%d",*fun()); printf("%d",*fun());
} }

int *fun() { int *fun() {


int *p, i; int *p;
p = &i; p = (int*)malloc(sizeof(int));
i = 10; *p = 10;
return p; return p;
} }
OUTPUT: 10
OUTPUT

Aug-19 18 Esc101, Pointers


Returning Pointer: Beware
• The function stack (except for the return value)
is gone once the function completes its
execution.
– All addresses of local variables and formal
arguments become invalid
– available for “reuse”
• But the heap memory, once allocated, remains
until it is explicitly “freed”
– even beyond the function that allocated it.
• addresses of static and global variables remain
valid throughout the program.
Aug-19 19 Esc101, Pointers
Stack vs heap
• Compiler controls the stack, programmer
controls the heap
An Intuition
 Think of executing a function as writing on a classroom
blackboard.
 Once the function finishes execution (the class is over),
everything on the blackboard is erased.
 What if we want to retain a message, after class is over?
 Solution could be to post essential information on a
“notice board”, which is globally accessible to all
classrooms.
 The blackboard of a class is like the stack (possibly
erased/overwritten in the next class), and the notice
board is like the heap.
Class Quiz
• The following program illustrates the value of declarations
of the form int (*ptr)[2] .
#include<stdio.h>
int main() { An equivalent
int a[] = {1,2,3}; assignment is:
int (*ptr)[2] = &a; int (*ptr)[2];
ptr = &a;
printf("%d\n", (*ptr)[0]);
printf("%d\n", (*ptr)[1]);

(*ptr)[0] = -1; OUTPUT:


printf("%d\n", a[0]); 1
return 0; 2
} -1
Aug-19 22 Esc101, Pointers

You might also like