Memory Management and

Transcription

1 Introduction to Computer and Program Design Lesson 6 Memory Management and File I/O James C.C. Cheng Department of Computer Science National Chiao Tung University

2 Dynamic memory allocation l malloc Syntax: #include <stdlib.h> void* malloc( size_t n ); where the size_t is the same as unsigned int malloc() returns a pointer to a chunk of memory of n bytes, or NULL if there is an error. The memory pointed to will be on the heap, not the stack, so make sure to free it when you are done with it. The returned pointer must be typecast l free Syntax: #include <stdlib.h> void free( void* ptr ); free() deallocates the space pointed to by ptr, freeing it up for future use. ptr must be NULL or used in a previous call to malloc(), otherwise a runtime error will occur on free(). 2

3 Dynamic memory allocation l calloc Syntax: #include <stdlib.h> void* calloc (size_t unit, size_t n ); calloc() returns a pointer to a chunk of memory of unit * n bytes with elements initialized t zero, or NULL if there is an error. The returned pointer must be typecast 3

4 Dynamic memory allocation l Example: char *pc = (char *)malloc(10); // 10 characters int *pi = (int *)malloc(sizeof(int) * 10); // 10 integers double *pd = (double *)malloc(80); // 10 doubles if( pc!= NULL && pi!= NULL && pd!= NULL){ // Check the allocation for(int i=0; i<10; ++i) pd[i] = pi[i] = pc[i] = i + 65; for(int i=0; i<10; ++i) printf("%c, %d, %f\n", pc[i], pi[i], pd[i]); // A~J } free(pc); free(pi); free(pd); l free a NULL pointer int *p; // Non-NULL free(p); // Runtime error! p = NULL; free(p); // OK! 4

5 Dynamic memory allocation int n = 1024 * 1024 * 128; // 128 MB double rtime; clock_t clk0, clk1; char *pc = (char *)malloc(n); // clk0 = clock(); for(int i=0; i<n; ++i) pc[i] = 0; clk1 = clock(); rtime = (double)(clk1 - clk0) / (double)clocks_per_sec; printf("iterative clearing time: %f\n", rtime); // The time is proportional to n free(pc); clk0 = clock(); pc = (char *)calloc(1,n); // re-allocating with initialization clk1 = clock(); rtime = (double)(clk1 - clk0) / (double)clocks_per_sec; printf("calloc time: %f\n", rtime); // it's constant time if the hardware supports calloc free(pc); 5

6 Dynamic memory allocation l Memory leaks and dangling Normal allocation Pointer Memory Memory leaks Memory dangling Pointer Memory Pointer Memory 6

7 Dynamic memory allocation l Memory Leaks There is no any pointer to point a allocated memory space Executing the system monitor to watch the memory usage Using two threads to execute the following program If the memory usage approach to the limitation, just stop the program char key = 0, end = 0; do{ // Create 64M byte for input buffer int n = 1024 * 1024 * 64; char *pc =(char *)malloc(n); memset(pc, 0, n); // Clear all data scanf("%s", pc); key = pc[0]; end = pc[1]; }while(key!= 'q' && key!='q' end!= 0); If the OS does not provide Garbage Collection, the allocated memory will never be released. Notice that the timing for releasing by garbage collection is when the program has been terminated. 7

8 Dynamic memory allocation l Memory Dangling A pointer points an unallocated memory space char *pc; *pc = 100; // Dangling pc = (char *)malloc(12); int *pi = (int *)pc; free(pi); *pc = 50; // Dangling 8

9 Dynamic memory allocation l Memory Manipulation Functions memset, memory setting: #include <memory.h> or #include <string.h> void* memset( void *dest, int c, size_t count ); Ø dest: the destination pointer Ø c: set the value, c & 0xFF, to each byte of dest Ø count: the number of byte to set Ø returns the value of dest int n = 3; int *p = (int *)malloc(sizeof(int)*n); memset(p, 0, sizeof(int)*n); for(int i=0; i<n; ++i) printf("%d, 0x%0X\n", p[i], p[i]); memset(p, 255, sizeof(int)*n); for(int i=0; i<n; ++i) printf("%d, 0x%0X\n", p[i], p[i]); memset(p, 65537, sizeof(int)*n); for(int i=0; i<n; ++i) printf("%d, 0x%0X\n", p[i], p[i]); memset((int *)memset(p, 0, 12) + 1, 255, 4) ; for(int i=0; i<n; ++i) printf("%d, 0x%0X\n", p[i], p[i]); 9

10 Dynamic memory allocation l Memory Manipulation Functions The needed time of memset int n = 1024 * 1024 * 128; // 128 MB double rtime; clock_t clk0, clk1; char *pc = (char *)malloc(n); clk0 = clock(); for(int i=0; i<n; ++i) pc[i] = 0; clk1 = clock(); rtime = (double)(clk1 - clk0) / (double)clocks_per_sec; printf("iterative clearing time: %f\n", rtime); // The needed time is proportional to n clk0 = clock(); memset(pc, 0, n); clk1 = clock(); rtime = (double)(clk1 - clk0) / (double)clocks_per_sec; printf("memset time: %f\n", rtime); /* The needed time is still proportional to n but less than iterative method */ free(pc); 10

11 Dynamic memory allocation l Memory Manipulation Functions memcpy, memory copy: #include <memory.h> or #include <string.h> void* memcpy(void *dest, const void *src, size_t count ); dest: the destination pointer src: the source pointer count: the number of byte to copy returns the value of dest If the source and destination overlap, this function does not ensure that the original source bytes in the overlapping region are copied before being overwritten. char s1[] = "Hello! My friend!"; // Why use char[]? const char *s2 = "Hi! Guys."; // Why use const char*? memcpy(s1+7, s2+4, 6); printf("%s\n", s1); // Hello! Guys. memcpy(s1+5, s1+7, 4); printf("%s\n", s1); // Maybe HelloGuysys., maybe not 11

12 Dynamic memory allocation l Memory Manipulation Functions memmove, memory move: #include <string.h> void *memmove( void *dest, const void *src, size_t count ); dest: the destination pointer src: the source pointer count: the number of byte to move returns the value of dest It is similar to memcpy, but memmove ensures the copy of overlapping region. char s1[] = "; memcpy(s1 + 2, s1, 5); printf("%s\n", s1); //

13 Dynamic memory allocation l Memory Manipulation Functions memcmp, memory compare: #include <memory.h> or #include <string.h> int memcmp( const void *buf1, const void *buf2, size_t n ); Ø buf1 and buf2: the pointers of memory Ø n: the number of byte to compare Ø Return Value: relationship of first n bytes of buf1 and buf2 < 0: buf1 less than buf2 0: buf1 identical to buf2 > 0: buf1 greater than buf2 char first[] = " "; char second[] = " "; printf( %d\n, memcmp( first, second, 19 ) ); // 0 printf( %d\n, memcmp( first, second, 20 ) ); // -1 printf( %d\n, memcmp( first + 2, second, 18 ) ); // 1 13

14 Dynamic memory allocation l Dynamic multi-dimension array int m=0, n=0,i,j; scanf("%d %d", &m, &n); int **pp = (int **)malloc(sizeof(int *) * m); for(i=0; i<m; ++i) pp[i] = (int *)malloc(sizeof(int) * n); for(i=0; i<m; ++i) for(j=0; j<n; ++j) pp[i][j] = i * 10 + j; for(i=0; i<m; ++i){ for(j=0; j<n; ++j) printf("%2d, ", pp[i][j]); printf("\n"); } /* Do not forget to free the allocated memory in reverse order of dimension */ for(i=0; i<m; ++i) free(pp[i]); free(pp); 14

15 Linked Lists l Linked List It consists of a sequence of data items such that in each item there is a pointer or a reference to link the next item. The memory addresses of elements may not be adjacent struct Node{ int data; Node *next; }; Node* NewNode(int data){ Node *p = (Node *)calloc(sizeof(node), 1); p->data = data; return p; } Node *phead = NewNode(0), *p = phead; for( int i=1; i<5; ++i, p = p->next) data next p->next = NewNode(i); // Creating the list p = phead; while(p!= NULL) { printf("%d\n", p->data); Node *ptmp = p; p = p->next; free(ptmp); // Release each item } 15

16 Linked Lists l Doubly-Linked List Each node has two pointers, one points the next node and the other points the previous node. struct Node{ int data; Node *next, *prev;}; Node* NewNode(int data){ Node *p = (Node *)calloc(sizeof(node), 1); } p->data = data; return p; Node *phead = NewNode(0); Node *p = phead; for( int i=1; i<5; ++i, p = p->next){ p->next = NewNode(i); p->next->prev = p; } while(p!= NULL) { printf("%d\n", p->data); Node *ptmp = p; p = p->prev; } p = phead; while(p!= NULL) { printf("%d\n", p->data); Node *ptmp = p; p = p->next; free(ptmp); // Release }

17 Arrays vs. Linked Lists l Performances Random access Push back Array: O(1) Dynamic Array: O(1) Doubly-Linked list: O(n) Doubly-Linked list: O(1) Random insertion Pop back Array: O(n) Dynamic Array: O(1) Doubly-Linked list: Doubly-Linked list: O(1) Search time + O(1) Random remove Push front Dynamic Array: O(n) Array: O(n) Doubly-Linked list: O(1) Doubly-Linked list: Search time + O(1) Pop front Dynamic Array: O(n) Doubly-Linked list: O(1) where n is the number of data elements 17

18 Arrays vs. Linked Lists l Performances Resize (from n to m) Array: O(m) Doubly-Linked list: O(m) Clear Array: O(n) n m Copy assignment Array: O(n) Doubly-Linked list: O(n) = Doubly-Linked list: O(n) Concatenation Array: O(n) Doubly-Linked list: O(1) Swap Array: O(n) Doubly-Linked list: O(1) 18

19 File System in OS l Microsoft Windows Filename DriveID : /DirctoryName/MainFileName.ExtensionName EX: Ø C:/test.txt Ø D:/MyDoc/Reports/ ppt Storage Devices Directories or Folders Files Files Directories or Folders Files 19

20 File System in OS l Microsoft Windows Filename DriveID Ø A and B are used for floppy disk drivers Ø C is the master boot device DirctoryName MainFileName ExtensionName = type name Path Absolute path = full path, Relative path Ø a path relative to the working directory Ø EX: if the the working directory is D:/ICP/2011 p ABC.h è D:/ICP/2011/ABC.h p /0515/test.dat è D:/ICP/2011/0515/test.dat p../xyz.txt è D:/ICP/xyz.txt (.. represents the parent diretory) p../../t_t.b è D:/T_T.b 20

21 File System in OS l Microsoft Windows FAT32 (File Allocation Table 32-bit) Max. file size: 4GB Max. length of MainFileName: 255 (in Windows), 8+3(DOS) Protection: Read-Only, Hidden and System exfat (Extended File Allocation Table) Max. file size: 64ZebiB = 2 70 bytes Max. length of MainFileName: 255 Protection: Read-Only, Hidden and System NTFS (New Technology File System) Max. file size: 16 TB Max. length of MainFileName: 255 UTF-16 code units Protection: Read-Only, Hidden, System and Windows Access Control List(ACL) 21

22 File I/O in C l I/O redirection Redirect the standard I/O to file I/O < input redirection > output redirection EX: MyProg.exe < input.txt > ouput.txt #include <stdio.h> void main(){ int x = 0, y = 0; do{ scanf("%d %d", &x, &y); printf("x = %d, y = %d, x * y = %d\n", x, y, x*y); }while( x>=0); } 22

23 File I/O in C l I/O redirection int fprintf(file *stream, const char *format [, argument ]...); stream is a pointer to point a I/O device It returns the number of bytes written. It returns -1 if function failed. #include <stdio.h> void main(){ int x = 10, y = 20; int r = printf("%d, %d\n", x, y); // 10, 20\n printf ("%d\n", r); // 7 r = fprintf( stdout, "%d, %d\n", x, y); // 10, 20\n printf ("%d\n", r); // 7 r = fprintf( stderr, "%d, %d\n", x, y); // 10, 20\n printf ("%d\n", r); // 7 } r = fprintf( stdin, "%d, %d\n", x, y); // printf ("%d\n", r); // -1 23

24 File I/O in C l Stream I/O 1. Open file FILE * file; file = fopen( "C:/MyDoc/data.txt", "r" ); /* filename format: DriveID : /DirctoryName/MainFileName.ExtensionName Each sub-directory name separated by a slash */ // Do not use the back-slash in filename, why? file = fopen( "C:\MyDoc\data.txt", "r" ); 2. Input (read) 3. Output (write) 4. Close file int x[10]; fread( &x, sizeof( int ), 10, file ); char *s = " Hello world"; fwrite( s, 1, strlen(s), file ); fclose(file); 24

25 File I/O in C l Stream I/O Open file FILE *fopen( const char *filename, const char *mode ); mode can be: Ø Ø Ø "r Opens for reading. The file must be existed. "w Opens an empty file for writing. If the given file exists, its contents are destroyed. "a Opens for appending; creates the file first if it doesn t exist. n Writing always at the end of the file (appending) Ø Ø Ø "r+ = r with writing. (The file must exist.) "w+ = w with reading "a+ = a with reading. 25

26 File I/O in C l Stream I/O Open file FILE *fopen( const char *filename, const char *mode ); mode with translation type : Ø mode + t : Open in text mode. (In MS Windows) n It inserts \r (0x0D) before \n (0x0A) in write-out data. n It discard \r (0x0D) before \n (0x0A) in read-in data. n EX: "rt", "wt", "at", "r+t", "w+t", "a+t" Ø mode + b : Open in binary mode. n EX: "rb", "wb", "ab", "r+b", "w+b", "a+b Ø t + mode and b + mode are wrong usages and fopen returns NULL n EX: bw, ta, Ø The default translation type depends on the OS. n You should explicitly specify the translation type at any time. 26

27 l File I/O in C Stream I/O fgec/fputc int fgetc(file *); int fputc(int, FILE*); è returns the character read/written if OK; Otherwise EOF fgets/fputs char * fgetc(char *, FILE *); è returns the result string if OK; Otherwise NULL int fputc(const char *, FILE*); è returns non-negative value if OK; Otherwise 27

28 l File I/O in C Stream I/O fread/fwrite size_t fread( void *buffer, size_t size, size_t count, FILE *stream ); size_t fwrite( const void *buffer, size_t size, size_t count, FILE *stream ); buffer : Storage location for data size: Item size in bytes count: Maximum number of items read/written stream: Pointer to the FILE structure è returns the number of full items actually read/written 28

29 File I/O in C l Stream I/O #include <stdio.h> #include <string.h> int main(){ FILE *pf = fopen("a.txt", "wt"); // try "wb" if(pf!= NULL){ char s[] = "Hello\nworld!\n"; fwrite(s, 1, strlen(s), pf); } fclose(pf); } pf = fopen("a.txt", "rt"); int c = 0; while( (c = fgetc(pf))!= EOF) printf("%02x ", c); printf("\n"); fclose(pf); // try "rb" 29

30 File I/O in C l Stream I/O Other Stream I/O functions: long ftell( FILE *stream ); Ø Gets the current position of a file pointer. int fseek( FILE *stream, long offset, int origin ); Ø Moves the file pointer to a specified location. Ø Origin = SEEK_CUR è current position + offset SEEK_ENDè files size(in byte) + offset SEEK_SET è offset int feof( FILE *stream ); Ø Returns true if the cursor is at the end of file int fprintf( FILE *stream, const char *format [, argument ]...); int fscanf( FILE *stream, const char *format [, argument ]...);

31 List Files In Directory l dirent.h #include <stdio.h> #include <dirent.h> int main(){ DIR *dirp; dirent *entry; if(dirp = opendir("c:/")){ while(entry = readdir (dirp)) printf("%s\n", entry->d_name); closedir (dirp); } getchar(); return 0; } dirent.h is known to be included in the following compilers: Turbo C++ (DOS) GCC (Cross-platform) MinGW (Microsoft Windows) Borland C++ Builder (Microsoft Windows) Microsoft Visual C++ does not include dirent.h Download the API package: