CS 11 C track: lecture 5 Last week: pointers This week: Pointer arithmetic Arrays and pointers Dynamic memory allocation The stack and the heap.

Slides:



Advertisements
Similar presentations
CSE 332: C++ exceptions Overview of C++ Exceptions Normal program control flow is halted –At the point where an exception is thrown The program call stack.
Advertisements

CS1061: C Programming Lecture 21: Dynamic Memory Allocation and Variations on struct A. O’Riordan, 2004, 2007 updated.
ECE Application Programming Instructor: Dr. Michael Geiger Fall 2012 Lecture 31: Dynamic memory allocation.
Growing Arrays in C By: Victoria Tielebein CS 265- Spring 2011.
Pointer applications. Arrays and pointers Name of an array is a pointer constant to the first element whose value cannot be changed Address and name refer.
Kernighan/Ritchie: Kelley/Pohl:
Memory Allocation. Memory A memory or store is required in a computer to store programs (or information or data). Data used by the variables in a program.
Memory allocation CSE 2451 Matt Boggus. sizeof The sizeof unary operator will return the number of bytes reserved for a variable or data type. Determine:
Malloc Recitation Section K (Kevin Su) November 5 th, 2012.
1 Pointers A pointer variable holds an address We may add or subtract an integer to get a different address. Adding an integer k to a pointer p with base.
Memory Arrangement Memory is arrange in a sequence of addressable units (usually bytes) –sizeof( ) return the number of units it takes to store a type.
1 CS 201 Dynamic Data Structures Debzani Deb. 2 Run time memory layout When a program is loaded into memory, it is organized into four areas of memory.
1 CSE 303 Lecture 11 Heap memory allocation ( malloc, free ) reading: Programming in C Ch. 11, 17 slides created by Marty Stepp
Adapted from Dr. Craig Chase, The University of Texas at Austin.
Pointers Applications
Outline Midterm results Static variables Memory model
CS50 SECTION: WEEK 4 Kenny Yu. Announcements  Problem Set 4 Walkthrough online  Problem Set 2 Feedback has been sent out  CORRECTION: Expect all future.
Addresses in Memory When a variable is declared, enough memory to hold a value of that type is allocated for it at an unused memory location. This is.
CMPSC 16 Problem Solving with Computers I Spring 2014 Instructor: Tevfik Bultan Lecture 12: Pointers continued, C strings.
1 C - Memory Simple Types Arrays Pointers Pointer to Pointer Multi-dimensional Arrays Dynamic Memory Allocation.
Lecture 13 Static vs Dynamic Memory Allocation
Stack and Heap Memory Stack resident variables include:
Chapter 0.2 – Pointers and Memory. Type Specifiers  const  may be initialised but not used in any subsequent assignment  common and useful  volatile.
Dynamic Memory Allocation The process of allocating memory at run time is known as dynamic memory allocation. C does not Inherently have this facility,
David Notkin Autumn 2009 CSE303 Lecture 12 October 24, 2009: Space Needle.
Computer Science and Software Engineering University of Wisconsin - Platteville 2. Pointer Yan Shi CS/SE2630 Lecture Notes.
Programming for Beginners Martin Nelson Elizabeth FitzGerald Lecture 15: More-Advanced Concepts.
Week 9 Part 1 Kyle Dewey. Overview Dynamic allocation continued Heap versus stack Memory-related bugs Exam #2.
University of Washington Today Finished up virtual memory On to memory allocation Lab 3 grades up HW 4 up later today. Lab 5 out (this afternoon): time.
1 C++ Classes and Data Structures Jeffrey S. Childs Chapter 4 Pointers and Dynamic Arrays Jeffrey S. Childs Clarion University of PA © 2008, Prentice Hall.
C++ Data Types Structured array struct union class Address pointer reference Simple IntegralFloating char short int long enum float double long double.
ECE 103 Engineering Programming Chapter 47 Dynamic Memory Alocation Herbert G. Mayer, PSU CS Status 6/4/2014 Initial content copied verbatim from ECE 103.
1 Dynamic Memory Allocation –The need –malloc/free –Memory Leaks –Dangling Pointers and Garbage Collection Today’s Material.
Dynamic Memory Allocation. Domain A subset of the total domain name space. A domain represents a level of the hierarchy in the Domain Name Space, and.
Dynamic memory allocation and Pointers Lecture 4.
Prachi A. Joshi Assistant Professor in CSE DIEMS,Aurangabad Unit 1 : Basic Concepts Pointers and dynamic memory allocation, Algorithm Specification, Data.
Pointers: Basics. 2 What is a pointer? First of all, it is a variable, just like other variables you studied  So it has type, storage etc. Difference:
Copyright 2005, The Ohio State University 1 Pointers, Dynamic Data, and Reference Types Review on Pointers Reference Variables Dynamic Memory Allocation.
CS 376b Introduction to Computer Vision 01 / 23 / 2008 Instructor: Michael Eckmann.
Pointers in C Computer Organization I 1 August 2009 © McQuain, Feng & Ribbens Memory and Addresses Memory is just a sequence of byte-sized.
CSE 332: C++ Statements C++ Statements In C++ statements are basic units of execution –Each ends with ; (can use expressions to compute values) –Statements.
1 Lecture07: Memory Model 5/2/2012 Slides modified from Yin Lou, Cornell CS2022: Introduction to C.
POINTERS Introduction to Systems Programming - COMP 1002, 1402.
1 Recall that... char str [ 8 ]; str is the base address of the array. We say str is a pointer because its value is an address. It is a pointer constant.
ENEE150 – 0102 ANDREW GOFFIN Dynamic Memory. Dynamic vs Static Allocation Dynamic  On the heap  Amount of memory chosen at runtime  Can change allocated.
MORE POINTERS Plus: Memory Allocation Heap versus Stack.
CMPSC 16 Problem Solving with Computers I Spring 2014 Instructor: Lucas Bang Lecture 11: Pointers.
Carnegie Mellon 1 Malloc Recitation Ben Spinelli Recitation 11: November 9, 2015.
Dynamic Memory Management & Static Class Members Lecture No 7 Object Oriented Programming COMSATS Institute of Information Technology.
BIL 104E Introduction to Scientific and Engineering Computing Lecture 9.
CSE 332: C++ Exceptions Motivation for C++ Exceptions Void Number:: operator/= (const double denom) { if (denom == 0.0) { // what to do here? } m_value.
DYNAMIC MEMORY ALLOCATION. Disadvantages of ARRAYS MEMORY ALLOCATION OF ARRAY IS STATIC: Less resource utilization. For example: If the maximum elements.
CSE 220 – C Programming malloc, calloc, realloc.
Dynamic Allocation in C
EGR 2261 Unit 11 Pointers and Dynamic Variables
Stack and Heap Memory Stack resident variables include:
ENEE150 Discussion 07 Section 0101 Adam Wang.
Checking Memory Management
CSCI206 - Computer Organization & Programming
Dynamic Memory CSCE 121 J. Michael Moore.
Dynamic Memory Allocation
Clear1 and Clear2 clear1(int array[], int size) { int i; for (i = 0; i < size; i += 1) array[i] = 0; } clear2(int *array, int size) {
Memory Allocation CS 217.
Pointers.
Pointers The C programming language gives us the ability to directly manipulate the contents of memory addresses via pointers. Unfortunately, this power.
CS111 Computer Programming
Dynamic Memory A whole heap of fun….
Dynamic Memory CSCE 121.
Module 13 Dynamic Memory.
Chapter 16 Pointers and Arrays
Presentation transcript:

CS 11 C track: lecture 5 Last week: pointers This week: Pointer arithmetic Arrays and pointers Dynamic memory allocation The stack and the heap

Pointers (from last week) Address: location where data stored Pointer: variable that holds an address int i = 10; int *j = &i; int k = 2 * (*j); /* dereference j */

Pointer arithmetic (1) Can add/subtract integers to/from pointers int arr[] = { 1, 2, 3, 4, 5 }; int *p = arr; /* (*p) == ? */ p++; /* (*p) == ? */ p += 2; /* (*p) == ? */ p -= 3; /* (*p) == ? */

Pointer arithmetic (2) arr p int arr[] = { 1, 2, 3, 4, 5 }; int *p = arr; /* (*p) == ? */

Pointer arithmetic (3) arr p p++; /* (*p) == ? */

Pointer arithmetic (4) arr p p += 2; /* (*p) == ? */

Pointer arithmetic (5) arr p p -= 3; /* (*p) == ? */

Let's try that using addresses only... Pointer arithmetic (6)

Pointer arithmetic (7) arr p int arr[] = { 1, 2, 3, 4, 5 }; int *p = arr; /* (*p) == ? */ x1234

Pointer arithmetic (8) arr p p++; /* (*p) == ? */ x1234 0x1238 (assume 4 byte integers)

Pointer arithmetic (9) arr p p+= 2; /* (*p) == ? */ x1234 0x1244 (0x1244 = 0x x10; 0x10 == 16 decimal or 4x4)

Pointer arithmetic (10) arr p p-= 3; /* (*p) == ? */ x1234

Pointer arithmetic (11) Get size of a type using the sizeof operator: printf("size of integer: %d\n", sizeof(int)); printf("size of (int *): %d\n", sizeof(int *)); N.B. sizeof is not a function takes a type name as an argument!

Pointer arithmetic (12) N.B. pointer arithmetic doesn't add/subtract address directly but in multiples of the size of the type in bytes int arr[] = { 1, 2, 3, 4, 5 }; int *p = arr; p++; /* means: p = p + sizeof(int);*/

Pointer arithmetic (13) arr p p++; /* (*p) == ? */ x1234 0x1238 (j = 0x sizeof(int) = 0x1238, not 0x1235)

Arrays and pointers (1) Arrays are pointers in disguise! Arrays: "syntactic sugar" for pointers int arr[] = {1, 2, 3, 4, 5}; printf("arr[3] = %d\n", arr[3]); printf("arr[3] = %d\n", *(arr + 3)); arr[3] and *(arr + 3) are identical! arr is identical to &arr[0]

Arrays and pointers (2) Can use pointer arithmetic wherever we use array operations; consider this: int i; double array[1000]; for (i = 1; i < 998; i++) { array[i] = (array[i-1] + array[i] + array[i+1]) / 3.0; }

Arrays and pointers (3) Exactly the same as: int i; double array[1000]; for (i = 1; i < 998; i++) { *(array+i) = (*(array+i-1) + *(array+i) + *(array+i+1)) / 3.0; }

Arrays and pointers (4) When you say *(array + i), you have to add i to array and dereference For large values of i, this is relatively slow Incrementing pointers by 1 is faster than adding a large number to a pointer Can use this fact to optimize the preceding code in an interesting way

Arrays and pointers (5) double array[1000]; double *p1, *p2, *p3; p1=array; p2=array+1; p3=array+2; for (i = 1; i < 998; i++) { *p2 = (*p1 + *p2 + *p3) / 3.0; p1++; p2++; p3++; }

Arrays and pointers (6)... array p1 p2 p3 Add *p1, *p2, *p3 together, divide by 3, put result into *p2

Arrays and pointers (7)... array p1 p2 p3 Increment *p1, *p2, *p3 by 1 each, continue

Arrays and pointers (8) We replaced 3 pointer additions with three pointer increments, which are usually faster Even more significant for 2-d arrays

Dynamic memory allocation (1) Recall that we can't do this: int n = 10; int arr[n]; /* not legal C */ However, often want to allocate an array where size of array not known in advance This is known as "dynamic memory allocation" dynamic as opposed to "static" (size known at compile time)

Dynamic memory allocation (2) Let's say we want to allocate memory for e.g. arrays "on the fly" Later will have to deallocate memory Three new library functions for this: void *malloc(int size) void *calloc(int nitems, int size) void free(void *ptr) All found in header file

void * What does void * mean? It's a "pointer to anything" Actual type either doesn't matter or will be given later by a type cast malloc / calloc return void * free takes a void * argument

Using malloc() (1) malloc() stands for "memory allocator" malloc() takes one argument: the size of the chunk of memory to be allocated in bytes recall: a byte == 8 bits an int is 32 bits or 4 bytes malloc() returns the address of the chunk of memory that was allocated

Using malloc() (2) malloc() is often used to dynamically allocate arrays For instance, to dynamically allocate an array of 10 ints : int *arr; arr = (int *) malloc(10 * sizeof(int)); /* now arr has the address of an array of 10 ints */

Using calloc() (1) calloc() is a variant of malloc() calloc() takes two arguments: the number of "things" to be allocated and the size of each "thing" (in bytes) calloc() returns the address of the chunk of memory that was allocated calloc() also sets all the values in the allocated memory to zeros ( malloc() doesn't)

Using calloc() (2) calloc() is also used to dynamically allocate arrays For instance, to dynamically allocate an array of 10 ints : int *arr; arr = (int *) calloc(10, sizeof(int)); /* now arr has the address of an array of 10 ints, all 0s */

malloc / calloc return value (1) malloc and calloc both return the address of the newly-allocated block of memory However, they are not guaranteed to succeed! maybe there is no more memory available If they fail, they return NULL You must always check for NULL when using malloc or calloc We sometimes leave it out here for brevity

malloc / calloc return value (2) bad: int *arr = (int *) malloc(10 * sizeof(int)); /* code that uses arr... */ good: int *arr = (int *) malloc(10 * sizeof(int)); if (arr == NULL) { fprintf(stderr, "out of memory!\n"); exit(1); } Always do this!

malloc() vs. calloc() malloc / calloc both allocate memory calloc has slightly different syntax as we've seen Most importantly: calloc() zeros out allocated memory, malloc() doesn't. calloc() a tiny bit slower I prefer calloc()

Using free() (1) malloc() and calloc() return the address of the chunk of memory that was allocated Normally, we store this address in a pointer variable When we have finished working with this chunk of memory, we "get rid of it" by calling the free() function with the pointer variable as its argument This is also known as "deallocating" the memory or just "freeing" it

Using free() (2) int *arr; arr = (int *) calloc(10, sizeof(int)); /* now arr has the address of an array of 10 ints, all 0s */ /* Code that uses the array... */ /* Now we no longer need the array, so "free" it: */ free(arr); /* Now we can't use arr anymore. */

Using free() (3) NOTE: When we free() some memory, the memory is not erased or destroyed Instead, the operating system is informed that we don't need the memory any more, so it may use it for e.g. another program Trying to use memory after freeing it can cause a segmentation violation (program crash)

Dynamic memory allocation (3) #include int *foo(int n) { int i[10]; /* memory allocated here */ int i2[n]; /* ERROR: NOT VALID! */ int *j; j = (int *)malloc(n * sizeof(int)); /* Alternatively: */ /* j = (int *)calloc(n, sizeof(int)); */ return j; } /* i’s memory deallocated here; j’s not */

Dynamic memory allocation (4) void bar(void) { int *arr = foo(10); arr[0] = 10; arr[1] = 20; /*... do something with arr... */ free(arr); /* deallocate memory */ } Not calling free() leads to memory leaks !

Memory leaks (1) void leaker(void) { int *arr = (int *)malloc(10 * sizeof(int)); /* Now have allocated space for 10 ints; * do something with it and return without * calling free(). */ } /* arr memory is leaked here. */ After leaker() returns, nothing points to memory allocated in the function  memory leak

Memory leaks (2) void not_leaker(void) { int *arr = (int *)malloc(10 * sizeof(int)); /* Now have allocated space for 10 ints; * do something with it. */ free(arr); /* free arr's memory */ } /* No leak. */ Here, we explicitly free() the memory allocated by malloc() before exiting the function.

Memory leaks (3) void not_leaker2(void) { int arr[10]; /* Now have allocated space for 10 ints; * do something with it. */ } /* No leak. */ Here, we don't have to free() the memory, since it was allocated locally (on the "stack"). "What's the stack?" (you may ask...)

Memory leaks (4) void crasher(void) { int arr[10]; /* Now have allocated space for 10 ints; * do something with it. */ free(arr); /* BAD! */ } Here, we free() memory we don't need to free! Anything can happen (e.g. core dump)

Memory leaks (5) Rules of thumb: 1) Any time you allocate memory using malloc() or calloc(), you must eventually call free() on that memory 2) You must free() the exact same pointer (address) that was returned from malloc() or calloc() 3) You don't have to free() the memory in the same function as the one where malloc/calloc was called

The stack and the heap (1) Local variables, function arguments, return value are stored on a stack Each function call generates a new "stack frame" After function returns, stack frame disappears along with all local variables and function arguments for that invocation

The stack and the heap (2) int contrived_example(int i, float f) { int j = 10; double d = 3.14; int arr[10]; /* do some stuff, then return */ return (j + i); }

The stack and the heap (3) /* somewhere in code */ int k = contrived_example(42, 3.3); What does this look like on the stack?

The stack and the heap (4) i = 42 f = 3.3 j = 10 d = 3.14 arr[10] = stack frame for contrived_example (42, 3.3) function arguments local variables (more frames) 52 return value

The stack and the heap (5) Another example: int factorial(int i) { if (i == 0) { return 1; } else { return i * factorial (i - 1); } }

The stack and the heap (6) Pop quiz: what goes on the stack for factorial(3) ? For each stack frame, have... no local variables one argument ( i ) one return value Each recursive call generates a new stack frame which disappears after the call is complete

The stack and the heap (7) i = 3 stack frame factorial(3) return value ?

The stack and the heap (8) i = 3 stack frame factorial(3) return value ? factorial(2) i = 2 ? stack frame

The stack and the heap (9) i = 3 stack frame factorial(3) return value ? factorial(2) i = 2 ? stack frame factorial(1) return value i = 1 ?

The stack and the heap (10) i = 3 stack frame factorial(3) return value ? factorial(2) i = 2 ? stack frame factorial(1) return value i = 1 ? stack frame return value factorial(0) i = 0 ?

The stack and the heap (11) i = 3 stack frame factorial(3) return value ? factorial(2) i = 2 ? stack frame factorial(1) return value i = 1 ? stack frame return value factorial(0) i = 0 1

The stack and the heap (12) i = 3 stack frame factorial(3) return value ? factorial(2) i = 2 ? stack frame factorial(1) return value i = 1 1

The stack and the heap (13) i = 3 stack frame factorial(3) return value ? factorial(2) i = 2 2 stack frame

The stack and the heap (14) i = 3 stack frame factorial(3) return value 6

The stack and the heap (15) factorial(3) result: 6

The stack and the heap (16) void foo(void) { int arr[10]; /* local (on stack) */ /* do something with arr */ } /* arr is deallocated */ Local variables sometimes called "automatic" variables; deallocation is automatic

The stack and the heap (17) arr[10] = stack frame for foo() local variables foo

The stack and the heap (18) The "heap" is the general pool of computer memory Memory is allocated on the heap using malloc() or calloc() Heap memory must be explicitly freed using free() Failure to do so  memory leak!

The stack and the heap (19) void foo2(void) { int *arr; /* allocate memory on the heap: */ arr = (int *)calloc(10, sizeof(int)); /* do something with arr */ } /* arr is NOT deallocated */

The stack and the heap (20) void foo3(void) { int *arr; /* allocate memory on the heap: */ arr = (int *)calloc(10, sizeof(int)); /* do something with arr */ free(arr); }

The stack and the heap (21) arr = 0x1234 stack frame local variables 0x1234 stack heap arr[0] arr[1] arr[2] arr[3] arr[4] (etc.) foo2 and foo3

The stack and the heap (22) 0x1234 stack heap arr[0] arr[1] arr[2] arr[3] arr[4] (etc.) (after foo2 exits, without freeing memory) memory leak

The stack and the heap (23) stack heap (etc.) arr[4] arr[3] arr[2] arr[1] arr[0] 0x1234 (after foo3 exits, with freeing memory)

Memory leaks Memory leaks are one of the worst kinds of bugs often, no harm done at all eventually may cause long-running program to crash out of memory very hard to track down Special tools (e.g. valgrind ) exist to debug memory leaks I supply you with a very simple leak checker

Next week struct typedef Linked lists