ECE 2400 Computer Systems Programming Fall 2018 Topic 6: C Dynamic Allocation

Transcription

1 ECE 2400 Computer Systems Programming Fall 2018 Topic 6: C Dynamic Allocation School of Electrical and Computer Engineering Cornell University revision: Bookcase Analogy 2 2 Using malloc to Allocate Memory 3 3 Using free to Deallocate Memory 8 4 Mapping Conceptual Storage to Machine Memory 10 Copyright 2018 Christopher Batten. All rights reserved. This handout was prepared by Prof. Christopher Batten at Cornell University for ECE 2400 / ENGRD 2140 Computer Systems Programming. Download and use of this handout is permitted for individual educational non-commercial purposes only. Redistribution either in part or in whole via both commercial or non-commercial means requires written permission. 1

2 1. Bookcase Analogy 1. Bookcase Analogy Book Heap Vol 1 Vol 2 Vol 3 D D M M M M C C C M* C D = Dictionary M = Math book C = Chemistry book E = ECE book M* = Pointer to Math book Vol 1 Vol 2 Vol 3 Vol 4 E E E M*M* E E E E Consider what happens if we run out of space in our bookcase We might create a of books next to the bookcase; this is a completely different space to store books with different mechanisms for adding and removing books The is a little less organized compared to the bookcase We use rolled up pieces of paper on the bookcase to point to various books in the 2

3 Let s revisit an example we saw in a previous topic Assume we wish to refactor appending a node to a chain into its own function 01 #include <stddef.h> typedef struct _node_t 04 { 05 int value; 06 struct _node_t* next_ptr; 07 } 08 node_t; node_t* append( node_t* n_ptr, 11 int value ) 12 { 13 node_t node; 14 node.value = value; 15 node.next_ptr = n_ptr; 16 return &node; 17 } int main( void ) 20 { 21 node_t* n_ptr = NULL; 22 n_ptr = append( n_ptr, 3 ); 23 n_ptr = append( n_ptr, 4 ); 24 n_ptr = append( n_ptr, 5 ); 25 return 0; 26 } 3

4 01 #include <stdlib.h> 02 #include <stddef.h> int* rand_array( size_t n ) 05 { 06 int a[n]; 07 for ( size_t i=0; i<n; i++ ) 08 a[i] = rand() % 100; 09 return a; 10 } int main( void ) 13 { 14 int* a = rand_array(3); 15 return 0; 16 } 4

5 Dynamic memory allocation uses the (new region of memory) Because dynamically allocated variables are not on a function s frame, they are not deallocated when a function returns We can dynamically allocate variables on the using malloc malloc is defined in stdlib.h malloc takes the number of bytes to allocate as a parameter and returns a pointer to the new variable allocated on the 01 int* a_ptr = 02 malloc( sizeof(int) ); *a_ptr = 42; int* b_ptr = 07 malloc( 4 * sizeof(int) ); b_ptr[0] = 1; 10 b_ptr[1] = 2; 11 b_ptr[2] = 3; 12 b_ptr[3] = 4; // typedef struct 15 // { 16 // double real; 17 // double imag; 18 // } 19 // complex_t; complex_t* complex_ptr = 22 malloc( sizeof(complex_t) ); complex_ptr->real = 1.5; 25 complex_ptr->imag = 3.5; 5

6 01 #include <stdlib.h> 02 #include <stddef.h> typedef struct _node_t 05 { 06 int value; 07 struct _node_t* next_ptr; 08 } 09 node_t; node_t* append( node_t* n_ptr, 12 int value ) 13 { 14 node_t* new_ptr = 15 malloc( sizeof(node_t) ); new_ptr->value = value; 18 new_ptr->next_ptr = n_ptr; 19 return new_ptr; 20 } int main( void ) 23 { 24 node_t* n_ptr = NULL; 25 n_ptr = append( n_ptr, 3 ); 26 n_ptr = append( n_ptr, 4 ); 27 n_ptr = append( n_ptr, 5 ); 28 return 0; 29 } 6

7 01 #include <stdlib.h> 02 #include <stddef.h> int* rand_array( size_t n ) 05 { 06 int* x = 07 malloc( n * sizeof(int) ); for ( size_t i=0; i<n; i++ ) 10 x[i] = rand() % 100; return x; 13 } int main( void ) 16 { 17 int* a = rand_array(3); 18 return 0; 19 } 7

8 3. Using free to Deallocate Memory What happens if we call rand_array multiple times? What happens if we reuse the pointer to the result? 01 #include <stdlib.h> 02 #include <stddef.h> int* rand_array( size_t n ) 05 { 06 int* x = 07 malloc( n * sizeof(int) ); for ( size_t i=0; i<n; i++ ) 10 x[i] = rand() % 100; return x; 13 } int main( void ) 16 { 17 int* a = rand_array(3); 18 a = rand_array(3); 19 return 0; 20 } 8

9 Memory leaks can cause programs to crash Every call to malloc must eventually correspond to a call to free free is defined in stdlib.h free takes a pointer to a dynamically allocated variable 01 #include <stdlib.h> 02 #include <stddef.h> int* rand_array( size_t n ) 05 { 06 int* x = 07 malloc( n * sizeof(int) ); for ( size_t i=0; i<n; i++ ) 10 x[i] = rand() % 100; return x; 13 } int main( void ) 16 { 17 int* a = rand_array(3); 18 free(a); 19 a = rand_array(3); 20 free(a); 21 return 0; 22 } 9

10 4. Mapping Conceptual Storage to Machine Memory 4. Mapping Conceptual Storage to Machine Memory 01 int main( void ) 02 { 03 char a[] = "foo"; 04 const char* b = "bar"; 05 char* c = 06 malloc( 4 * sizeof(char) ); 07 strcpy( c, a ); 08 free(c); 09 return 0; 10 } Memory (4B word addr) static data 10

11 4. Mapping Conceptual Storage to Machine Memory 11