1 / 23

Dynamic Memory Allocation, Structure pointers

Dynamic Memory Allocation, Structure pointers. Lecture 17b 20.3.2001. Basic Idea. Many a time we face situations where data is dynamic in nature. Amount of data cannot be predicted beforehand. Number of data item keeps changing during program execution.

Download Presentation

Dynamic Memory Allocation, Structure pointers

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Dynamic Memory Allocation,Structure pointers Lecture 17b 20.3.2001. Sudeshna Sarkar, CSE, IIT Kharagpur

  2. Basic Idea • Many a time we face situations where data is dynamic in nature. • Amount of data cannot be predicted beforehand. • Number of data item keeps changing during program execution. • Such situations can be handled more easily and effectively using dynamic memory management techniques. Sudeshna Sarkar, CSE, IIT Kharagpur

  3. C language requires the number of elements in an array to be specified at compile time. • Often leads to wastage or memory space or program failure. • Dynamic Memory Allocation • Memory space required can be specified at the time of execution. • C supports allocating and freeing memory dynamically using library routines. Sudeshna Sarkar, CSE, IIT Kharagpur

  4. Memory Allocation Process in C Local variables Stack Free memory Heap Global variables Permanent storage area Instructions Sudeshna Sarkar, CSE, IIT Kharagpur

  5. The program instructions and the global variables are stored in a region known as permanent storage area. • The local variables are stored in another area called stack. • The memory space between these two areas is available for dynamic allocation during execution of the program. • This free region is called the heap. • The size of the heap keeps changing Sudeshna Sarkar, CSE, IIT Kharagpur

  6. 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. Sudeshna Sarkar, CSE, IIT Kharagpur

  7. Dynamic Memory Allocation • used to dynamically create space for arrays, structures, etc. int main () { int *a ; int n; .... a = (int *) calloc (n, sizeof(int)); .... } a = malloc (n*sizeof(int)); Sudeshna Sarkar, CSE, IIT Kharagpur

  8. Space that has been dynamically allocated with either calloc() or malloc() does not get returned to the function upon function exit. • The programmer must use free() explicitly to return the space. • ptr = malloc (...) ; • free (ptr) ; Sudeshna Sarkar, CSE, IIT Kharagpur

  9. void read_array (int *a, int n) ; int sum_array (int *a, int n) ; void wrt_array (int *a, int n) ; int main () { int *a, n; printf (“Input n: “) ; scanf (“%d”, &n) ; a = calloc (n, sizeof (int)) ; read_array (a, n) ; wrt_array (a, n) ; printf (“Sum = %d\n”, sum_array(a, n); } Sudeshna Sarkar, CSE, IIT Kharagpur

  10. void read_array (int *a, int n) { int i; for (i=0; i<n; i++) scanf (“%d”, &a[i]) ; } void sum_array (int *a, int n) { int i, sum=0; for (i=0; i<n; i++) sum += a[i] ; return sum; } void wrt_array (int *a, int n) { int i; ........ } Sudeshna Sarkar, CSE, IIT Kharagpur

  11. Arrays of Pointers • Array elements can be of any type • array of structures • array of pointers Sudeshna Sarkar, CSE, IIT Kharagpur

  12. int main (void) { char word[MAXWORD]; char * w[N]; /* an array of pointers */ int i, n; /* n: no of words to sort */ for (i=0; scanf(“%s”, word) == 1); ++i) { w[i] = calloc (strlen(word)+1, sizeof(char)); if (w[i] == NULL) exit(0); strcpy (w[i], word) ; } n = i; sortwords (w, n) ; wrt_words (w, n); return 0; } Sudeshna Sarkar, CSE, IIT Kharagpur

  13. Input : A is for apple or alphabet pie which all get a slice of come taste it and try w 0 A \0 1 i s \0 2 f o r \0 3 a p p l e \0 17 t r y \0 Sudeshna Sarkar, CSE, IIT Kharagpur

  14. void sort_words (char *w[], int n) { int i, j; for (i=0; i<n; ++i) for (j=i+1; j<n; ++j) if (strcmp(w[i], w[j]) > 0) swap (&w[i], &w[j]) ; } void swap (char **p, char **q) { char *tmp ; tmp = *p; *p = *q; *q = tmp; } Sudeshna Sarkar, CSE, IIT Kharagpur

  15. Before swapping w w[i] f o r \0 a p p l e \0 w[j] Sudeshna Sarkar, CSE, IIT Kharagpur

  16. After swapping w w[i] f o r \0 a p p l e \0 w[j] Sudeshna Sarkar, CSE, IIT Kharagpur

  17. Pointers to Structure Sudeshna Sarkar, CSE, IIT Kharagpur

  18. Pointers and Structures • You may recall that the name of an array stands for the address of its zero-th element. • Also true for the names of arrays of structure variables. • Consider the declaration: struct stud { int roll; char dept_code[25]; float cgpa; }class[100], *ptr ; Sudeshna Sarkar, CSE, IIT Kharagpur

  19. The name class represents the address of the zero-th element of the structure array. • ptr is a pointer to data objects of the type struct stud. • The assignment ptr = class ; • will assign the address of class[0] to ptr. • When the pointer ptr is incremented by one (ptr++) : • The value of ptr is actually increased by sizeof(stud). • It is made to point to the next record. Sudeshna Sarkar, CSE, IIT Kharagpur

  20. Once ptr points to a structure variable, the members can be accessed as: ptr –> roll ; ptr –> dept_code ; ptr –> cgpa ; • The symbol “–>” is called the arrow operator. Sudeshna Sarkar, CSE, IIT Kharagpur

  21. Warning • When using structure pointers, we should take care of operator precedence. • Member operator “.” has higher precedence than “*”. • ptr –> roll and (*ptr).roll mean the same thing. • *ptr.roll will lead to error. • The operator “–>” enjoys the highest priority among operators. • ++ptr –> roll will increment roll, not ptr. • (++ptr) –> roll will do the intended thing. Sudeshna Sarkar, CSE, IIT Kharagpur

  22. Program to add two complex numbers using pointers typedef struct { float re; float im; } complex; main() { complex a, b, c; scanf (“%f %f”, &a.re, &a.im); scanf (“%f %f”, &b.re, &b.im); add (&a, &b, &c) ; printf (“\n %f %f”, c,re, c.im); } Sudeshna Sarkar, CSE, IIT Kharagpur

  23. void add (complex * x, complex * y, complex * t){ • t->re = x->re + y->re ; • t->im = x->im + y->im ; • } Sudeshna Sarkar, CSE, IIT Kharagpur

More Related