Module 13: C Language Dynamic Memory

Question 1

dynamic

Answer 1

means “at run-time” (not “at compile-time”); compiler does not have enough information to make a final decition

Question 2

size_t

Answer 2

a type_def type for an unsigned int

Question 3

void* malloc(size_t size)

Answer 3

returns a pointer to a region on the heap of size bytes. if it’s successful, space is contiguous. if a heap can’t fulfill request, returns NULL, think of it as creating a reservation for a region of memory that only you can write to, until you call free() and release that reservation

Question 4

void free(void* ptr)

Answer 4

clears the reservation for address pointed to by ptr and for all the rows initially reserved by the corresponding call to malloc(). example: you ask malloc() for 6 rows. when you call free, it will release the reservation on those six rows

Question 5

sizeof()

Answer 5

an operator in C that will compute the size of the operand; works on any data type, even structs

Question 6

memory leak

Answer 6

memory on heap you no longer have a reference to. example: int* my_pointer = malloc(4). my_pointer is a reference to the memory you have reserved. but if you then alter it: my_pointer = NULL, you have lost the only reference you had to your reservation on the heap. now you can never return to that region or even release it using free()

Question 7

linked list

Answer 7

a type of data structure itself, the purpose of which is to “link” groups of data together. we call the “groups” nodes in the context of a linked list

Question 8

declaration

Answer 8

when you describe something to the compiler but don’t actually ask for space for it

Question 9

header file

Answer 9

must end in .h but can only contain “declarations” and not “definitions”

Question 10

steps for malloc():

Answer 10

char str;
str = (char) malloc(10);
strcpy(str, “OMCIT593”);

Question 11

steps for free()

Answer 11

remember: each call to malloc() requires a corresponding call to free()

Question 12

advantages of linked lists

Answer 12

• growth of the list can be dynamic (occur while programming is running)
• make efficient use of memory
• shrinking/reordering our list can also be dynamic

Question 13

disadvantages of linked lists

Answer 13

pointer and memory management are tricky

more difficult to find things, i.e., traverse the list

Question 14

memory leaks

Answer 14

most common cause:

• you were done with memory you had allocated
• then you overwrote the last pointer that pointed to it
• but you forgot to call free() on it first

block is gone (cannot be reallocated) for the duration of the program

if you do this repeatedly, your program won’t have heap anymore!

Question 15

garbage collection

Answer 15

helps avoid leaks while saving you from having to call free()
“reclaims” everything in heap that is not pointed to
C does not have this (Java does!)

Question 16

“buffer overflows”

Answer 16

example: ask for 10 bytes but write 11
bad to do in general, but especially bad in the heap
C does not check for this, but Java does

Question 17

Remember to check the return value of malloc()

Answer 17

malloc() is allowed to return NULL (out of memory)

should check for NULL after every call to malloc()

Question 18

Passing a pointer to the middle of allocated region to free()

Answer 18

free() won’t be able to find the block