CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified...
-
Upload
sage-copping -
Category
Documents
-
view
217 -
download
0
Transcript of CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified...
![Page 1: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/1.jpg)
CSC 270 – Survey of Programming Languages
C Lecture 6 – Pointers and Dynamic Arrays
Modified from Dr. Siegfried
![Page 2: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/2.jpg)
What is a Pointer?
• A point is a variable whose values are memory addresses.
• We call it a pointer because we envision the address as “pointing” to where the value is stored.
• Deferencing a pointer gets the value at that memory address
• Reference parameters make use of pointers.• Arrays are passed by reference because the name
of an array (without an index following it) is a pointer to where the array is stored.
![Page 3: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/3.jpg)
Pointer Variables
• When we writedouble x;
we are saying that there is a double-precision value stored in memory and x is the value at that location.
• When we writedouble *p
we are saying that p is a pointer to a double value that is stored in memory and that p’s value is the address at which the value is stored. (Read backwards)
Note: could be double* p instead.
![Page 4: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/4.jpg)
Assign and Dereference Pointers#include <stdio.h>int main(void){int a;int * aPtr;a = 7;aPtr = &a;printf("The address of a is %p\nThe value of aPtr is %p\n",&a,aPtr);printf("The value of a is %d\nThe value of *aPtr is %d\n",a,*aPtr);printf("\nThe result of &*aPtr is %p\n and the value of *&aPtr is %p\n", &*aPtr,*&aPtr);printf("\nThe result of *&a is %d\n",*&a);//CANT DO THIS because you cannot deference an int: printf("%d",*a);}
![Page 5: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/5.jpg)
Deferencing Result
• The address of a is 0x7fff22344cfc• The value of aPtr is 0x7fff22344cfc• The value of a is 7• The value of *aPtr is 7
• The result of &*aPtr is 0x7fff22344cfc• and the value of *&aPtr is 0x7fff22344cfc
• The result of *&a is 7
![Page 6: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/6.jpg)
Declaring and Using Pointer Variables
• We can declare several pointer variables in the same statement, even together with variable of the type to which they point:int v1, v2, v3, *p1, *p2, *p3;
• We can assign values to pointers using the referencing operator (&):p1 = &v1; /* p1 holds the address
where v1 is stored.*/
![Page 7: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/7.jpg)
Using Pointers
v1 = 0;
p1 = &v1;
*p1 = 42;
printf("%d\n", v1);
printf("%d\n", *p1);
Output42
42
![Page 8: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/8.jpg)
Pointers and the Assignment Operation
• Assign a pointer to another pointer
p2 = p1
printf("%d\n", *p2);will also produce 42 (unless v1’s value was changed).
![Page 9: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/9.jpg)
p1 = p2
p1 8
p2 9
p1 8
p2 9
Before After
![Page 10: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/10.jpg)
*p1 = *p2
p1 8
p2 9
p1 9
p2 9
Before After
![Page 11: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/11.jpg)
malloc()
• The library function malloc() is used to allocate memory for a data item and then to assign its address to a pointer variable.
• The prototype for malloc() is void* malloc (size_t size);
where size_t is an unsigned integer type• Variables that are created using malloc() are called
dynamically allocated variables.• Found in stdlib.h
![Page 12: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/12.jpg)
malloc()- An Example
p1 = (int *) malloc(sizeof(int));
scanf("%d", p1);
*p1 = *p1 + 7;
printf("%d", *p1);
![Page 13: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/13.jpg)
free()
• The function free() eliminates a dynamic variable and returns the memory that the dynamic variable occupied to the heap. It can be re-used.
• The prototype:void free (void* ptr);
• After the delete statement, p’s value is undefined.
![Page 14: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/14.jpg)
Demo Dynamic Variables#include <stdio.h>
#include <stdlib.h>
int main (void){
int *p1, *p2;
p1 = (int *) malloc(sizeof(int));
*p1 = 42;
p2 = p1;
printf ("*p1 == %d\n *p2 == %d\n", *p1,*p2);
*p2 = 53;
puts ("\n\nAfter *p2 = 53:\n");
printf("*p1 == %d\n *p2 == %d\n", *p1,*p2);
p1 = (int *) malloc(sizeof(int));
![Page 15: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/15.jpg)
*p1 = 88;
*p2 = 33;
puts ("\n\nAfter *p1 = 88 and *p2 = 33");
puts("and created new var for p1 to reference:\n");
printf("*p1 == %d\n *p2 == %d\n", *p1,*p2);
free(p1);
// why not free p1 before second malloc???
free(p2);
return(0);
}
![Page 16: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/16.jpg)
Output from BasicPointer.c*p1 == 42 *p2 == 42
After *p2 = 53:
*p1 == 53 *p2 == 53
After *p1 = 88 and *p2 = 33and created new var for p1 to reference:
*p1 == 88 *p2 == 33
![Page 17: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/17.jpg)
Explaining BasicPointer.c
?p1
?p2
int *p1, *p2;
p1 ?
?p2
p1 = (int *) malloc(sizeof(int));
![Page 18: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/18.jpg)
Explaining BasicPointer.c
p1 42
?p2
*p1 = 42;
p1 42
p2
p2 = p1;
![Page 19: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/19.jpg)
Explaining BasicPointer.c
p1 53
p2
*p2 = 53;
p1 ?
p2 53
p1 = (int *) malloc(sizeof(int));
![Page 20: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/20.jpg)
Explaining BasicPointer.c
p1 88
p2 33
*p1 = 88; *p2 = 33
![Page 21: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/21.jpg)
Basic Memory Management
• The heap is a special area of memory reserved for dynamically allocated variables.
• Compilers would return NULL if there wasn’t enough memory when calling malloc().
• It could potentially cause the program to abort execution.
![Page 22: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/22.jpg)
Stopping Errors with malloc()
int *p;
p = (int *) malloc(sizeof(int));
if (p == NULL) {
printf("Insufficient memory\n");
exit(1);
}
/* If malloc()succeeded, the program
continues here */
![Page 23: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/23.jpg)
NULL
• NULL is actually the number 0, but we prefer to think of it as a special-purpose value..
• NULL’s definition appears in <cstdlib>, and <stdlib.h>
• NULL can be assigned to a pointer variable of any type.
![Page 24: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/24.jpg)
Dangling Pointers
• A dangling pointer is an undefined pointer. It either has no address assigned yet or what it pointed to is now gone.
• If p is a dangling pointer, then *p references memory that has been returned to the heap and the result is unpredictable.
• C has no built-in mechanism for checking for dangling pointers.– For this reason, it is always a good idea to set dangling
pointers to NULL.
![Page 25: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/25.jpg)
Dynamic Variables
• Variables created using the malloc function are called dynamic variables (they are created and destroyed while the program is running.
• Storage for local variables are allocated when the function is called and de-allocated when the function call is completed. They are called automatic variables because this is all done automatically.
• Variables declared outside any function or class definition are called external (or global) variables. They are statically allocated because their storage is allocated when the program is translated.
![Page 26: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/26.jpg)
typedef
• You can define a pointer type name so that pointer variables can be declared like other variables.
• E.g.,typedef int * IntPtr;
IntPtr p; // equivalent to int *p;
• typedef can be used to define any kind of data type:typedef double Kilometers;
Kilometers distance;
![Page 27: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/27.jpg)
Dynamic Arrays
• A dynamic array is an array whose size is not specifically when you write the program.
• Exampleint a[10];
typedef int *IntPtr;
IntPtr p;
…
p = a; /* p[i] refers to a[i] */
![Page 28: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/28.jpg)
ArrayDemo.c
// Program to demonstrate that an array variable is// a kind of pointer variable#include <stdio.h>
typedef int* IntPtr;
int main(void){
IntPtr p;int a[10];int index;
for (index = 0; index < 10; index++)a[index] = index;
![Page 29: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/29.jpg)
p = a;
for (index = 0; index < 10; index++)printf("%d ", p[index]);
printf("\n");
for (index = 0; index < 10; index++)p[index] = p[index] + 1;
for (index = 0; index < 10; index++)printf("%d ", a[index]);
printf("\n");
return(0);}Output0 1 2 3 4 5 6 7 8 91 2 3 4 5 6 7 8 9 10
![Page 30: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/30.jpg)
Creating and Using Dynamic Arrays
• You do not always know in advance what size an array should be. Dynamic arrays allow the programmer to create arrays that are flexible in size:typedef double *DoublePtr;
DoublePtr d;
d = (double *)
malloc (10*sizeof(double));
![Page 31: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/31.jpg)
DynArrayDemo.c// Searches a list of numbers entered at the
// keyboard
#include <stdio.h>
#include <stdlib.h>
typedef int* IntPtr;
void fillArray(int a[], int size);
// Precondition: size is the size of the array a
// Postcondition: a[0] through a[size-1] have been
// filled with values read from the keyboard.
![Page 32: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/32.jpg)
int search(int a[], int size, int target);
// Precondition: size is the size of the array a
// The array elements a[0] through a[size-1] have
// values.
// If target is in the array, returns the first index
// of target
// If target is not in the array, returns -1.
int main(void)
{
printf("This program search a list of "
" numbers.\n");
int arraySize, target;
int location;
![Page 33: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/33.jpg)
printf("How many numbers will be on the "
"list\t?");
scanf("%d", &arraySize);
IntPtr a;
a = (int *) malloc(arraySize*sizeof(int));
fillArray(a, arraySize);
printf("Enter a value to search for:\t?");
scanf("%d", &target);
location = search(a, arraySize, target);
![Page 34: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/34.jpg)
if (location == -1)
printf("%d is not in the array.\n",
target);
else
printf("%d is element %d in the array.\n"
, target, location);
free(a);
return(0);
}
![Page 35: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/35.jpg)
// Uses the library <stdio.h>:
void fillArray(int a[], int size)
{
printf("Enter %d integers.", size);
int index;
for ( index = 0; index < size; index++)
scanf("%d", &a[index]);
}
![Page 36: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/36.jpg)
int search(int a[], int size, int target)
{
int index = 0;
while ((a[index] != target) && (index < size))
index++;
if (index == size) /* If target is not in a */
index = -1;
return index;
}
![Page 37: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/37.jpg)
Why use free(a);?
• The free(a) function call is necessary if the program will do other things after finishing its use of a dynamic array, so the memory can be reused for other purposes.
![Page 38: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/38.jpg)
PtrDemo.c
#include <stdio.h>
#include <stdlib.h>
int* doubler (int a[], int size);
/*
* Precondition: size is the size of the array a
* A indexed variables of a have values.
* Returns: a pointer to an array of the same size
* as a in which each index variable is
* double the corresponding element in a.
*/
![Page 39: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/39.jpg)
int main(void)
{
int a[] = {1, 2, 3, 4, 5};
int *b;
b = doubler(a, 5);
int i;
printf("array a:\n");
for (i = 0; i < 5; i++)
printf("%d ", a[i]);
printf("\n");
printf("Array b:\n");
for (i = 0; i < 5; i++)
printf("%d ", b[i]);
![Page 40: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/40.jpg)
printf("\n");
free(b);
return(0);
}
int *doubler(int a[], int size)
{
int *temp;
temp = (int *) malloc(size*sizeof(int));
int i;
for (i = 0; i < size; i++)
temp[i] = 2*a[i];
return temp;
}
![Page 41: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/41.jpg)
Output from PtrDemo.cpp
array a:
1 2 3 4 5
Array b:
2 4 6 8 10
![Page 42: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/42.jpg)
Pointer Arithmetic
• If p is a pointer, p++ increment p to point to the next element and p += i; has p point i elements beyond where it currently points.
• Exampletypedef double* DoublePtr;DoublePtr d;d = new double[10];
• d +1 points to d[1], d+2 points to d[2].• If d = 2000, d+1 = 2008 (double use 4 bytes of
memory).
![Page 43: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/43.jpg)
Pointer Arithmetic – An Example
for (i = 0; i < arraySize; i++)
printf("%d ", *(d+i));
is equivalent to
for (i = 0; i < arraySize; i++)
printf("%d ", d[i]);
![Page 44: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/44.jpg)
Pointers and ++ and --
• You can also use the increment and decrement operators, ++ and – to perform pointer arithmetic.
• Example• d++ advances the pointer to the address of the
next element in the array and d–- will set the pointer to the address of the previous element in the array.
![Page 45: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/45.jpg)
Multidimensional Dynamic Arrays
• Multidimensional dynamic arrays are really arrays of arrays or arrays of arrays of arrays, etc.
• To create a 2-dimensional array of integers, you first create an array of pointers to integers and create an array of integers for each element in the array.
![Page 46: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/46.jpg)
Creating Multidimensional Arrays
// Create a data type for to integerstypedef int * IntArrayPtr;
// Allocate an array of 3 integer pointersIntArrayPtr *m = (int**)malloc(3*sizeof (int *));
// Allocate for 3 arrays of 4 integers each.int i;for ( i = 0; i < 3; i++)
m[i] = (int *) malloc(4*sizeof(int));
// Initialize them all to 0for ( i = 0; I < n; i++)
for (int j = 0; j < n; j++)m[i][j] = 0;
![Page 47: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/47.jpg)
free
• Since m is an array of array, each of the arrays created with malloc() in the for loop must be returned to the heap using a call to free() and then afterward, m itself must be returned using free().
![Page 48: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/48.jpg)
MultArrayDemo.c#include<stdio.h>
#include<stdlib.h>
typedef int*IntArrayPtr;
int main(void)
{
int d1, d2;
int i, j;
IntArrayPtr *m;
printf("Enter the row and column dimensions"
" of the array:\t");
scanf("%d%d", &d1, &d2);
![Page 49: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/49.jpg)
m = (IntArrayPtr *)
malloc(d1 *sizeof(IntArrayPtr));
for (i = 0; i < d1; i++)
m[i] = (int *) malloc(d2 * sizeof(int));
/* m is now a d1-by-d2 array. */
printf("Enter %d rows of %d integers each:\n",
d1, d2);
for (i = 0; i < d1; i++)
for (j = 0; j < d2; j++)
scanf("%d", &m[i][j]);
printf("Echoing the two-dimensional array:\n");
![Page 50: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/50.jpg)
for (i = 0; i < d1; i++){
for (j = 0; j < d2; j++)
printf("%d ", m[i][j]);
printf("\n");
}
for (i = 0; i < d1; i++)
free(m[i]);
free(m);
return (0);
}
![Page 51: CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.](https://reader036.fdocuments.net/reader036/viewer/2022062712/56649c765503460f9492ad43/html5/thumbnails/51.jpg)
OutputEnter the row and column dimensions of the array: 3 4
Enter 3 rows of 4 integers each:
1 2 3 4
5 6 7 8
9 0 1 2
Echoing the two-dimensional array:
1 2 3 4
5 6 7 8
9 0 1 2