Introduction to pointers and memory management in C

1

Uri DekelCarnegie Mellon University

[email protected]

Introduction to Pointers andIntroduction to Pointers and Memory Management in C Memory Management in C

2

AssumptionsAssumptions

Audience familiar with:VariablesControl structuresFunction callsArrays and strings

Not familiar withComputer memoryImplementation of variables and function calls

Intro to Pointers and Memory in C

3

TopicsTopics

Computer memory in generalImplementation of variables and function calls

Pointers and overcoming function limitations

Pointer arithmetic and arraysNeed and risks of dynamic memory allocation


4

FocusFocus

Understanding of concepts and techniques

Reasoning for use of specific techniques

Caveats to watch out for


5

Note on C versionsNote on C versions

Presented material is in C90 (old “Ansi C”)Supported by nearly all compilersBasis for most legacy code

Newer C’99 and later is differentAllows some C++ conventionsIntroduces new featuresNot fully supported by all compilers


6

Introduction to Computer Memory

Intro to Pointers and Memory in C Background

DynamicPointers

7

Why do we need memory?Why do we need memory?

CPU operates on data in a handful of registers

Not enough for most applicationsMemory is vast collection of “value

holders”Values copied to/from registers

Background

DynamicPointersIntro to Pointers and Memory in C

8

Memory needs to be organizedMemory needs to be organized

Must be able to locate previously stored valueCan’t rely on actual value

Programmers see linear address space

Typical address space is vast32bit or 64bit

Background


9

What do we do with multi-byte What do we do with multi-byte values?values?Size of cell is limited

Typically byte (8 bits, 0—255)Spread values in contiguous cells

Only need to know starting address and size

Background


10

What do we do with multi-byte What do we do with multi-byte values?values?Breakup of large values must be consistent with their reassemblyWhere do we store the more-significant digits?

Background


11

Virtual MemoryVirtual Memory

Modern OSs provide separate address space to processesCertain logical addresses mapped to physical addresses

Mechanism transparentOverlapping addresses do not interfere

Not every address is mapped!

Background


12

Variables and Function Calls in C

Background


13

VariablesVariables

A symbolic name for a specific memory locationCan read and write contentsGuaranteed to exist every time it is used

Type used to reassemble and interpret valueHow many cells? How value is broken down

13

Background


14

Automatic variablesAutomatic variables

Declared at a beginning of a blockLifetime and scope correspond to block

Background


15

Allocating space for variablesAllocating space for variables

Variables are allocated space on stackLast-In-First-Out structureHas a fixed base and grows “up” or “down”

Newer variables allocated “above” earlierNewer variables “die” before olderStack resides in specific memory segment

Background


16

Program code and memoryProgram code and memory

Our program (“code”) is stored in memoryDedicated “code segment”Every instruction has an addressEvery function has an address

Most instructions are contiguousCPU uses instruction pointer (IP) register for next address to executeExecution typically sequentialIP changes on branches

Background


17

Stack example (In function)Stack example (In function)

Background


18

Stack example (In function)Stack example (In function)

Background


19

What happens in function call?What happens in function call?

Copies of argument values pushed into stack

Return address pushed into stack

CPU IP aimed at beginning of function block

Background


20

What happens in function call?What happens in function call?

Background


21

Returning from functions…Returning from functions…

All automatic variables of function are poppedReturn address is poppedAll passed arguments are poppedIP aimed at next instruction to execute in

original functionReturn value in register or stack

Background


22

Returning from functions…Returning from functions…

Background


23

Attempting to write a swap Attempting to write a swap function…function…

Background


24


Background


25


Background


26


Background


27

Pointers

Background DynamicPointers


28

Why pass-by-pointer?Why pass-by-pointer?

Functions always pass values by copying (pass-by-value)

They return a single value by copyingChanges to arguments in invoked functions have

NO IMPACTon corresponding variables in invoking function

To change, we must “break through” to earlier stack locations.

Solution: 1) Pass address of value holder represented by

variable2) Use that address to write directly into the

value holderBackground DynamicPointer

sIntro to Pointers and Memory in C

29

PointersPointers

A pointer is a variable!It has an address and stores a valueBut the value can be interpreted as an address

X myX – declare variable of type XX* pX – declare pointer to value of type

XPointer size depends on address space, not type!



30

Assigning values to pointersAssigning values to pointers

Arbitrary numeric valuesAddress of variablesValues of other pointersAddress of functions (outside our scope)Caveat: Avoid pointing at temporaries!



31

Dereferencing pointersDereferencing pointers

Accessing the pointed-to memory cellIf pX is pointer, (*pX) is the valueRoughly, var is equivalent to (*(&var))Can serve as an lvalue! (can assign into it)



32

Implementing SwapImplementing Swap



33




34




35




36

Caveat – Uninitialized pointersCaveat – Uninitialized pointers

Uninitialized pointers can contain junk

Dereferencing leads to random addressData overwrites, segmentation faults, etc.



37

Caveat – NULL pointersCaveat – NULL pointers

Pointers to NULL should not be dereferenced

Equivalent to accessing address 0Access may result in “Bus Error” on UNIX



38

Caveats – Dangling referencesCaveats – Dangling references

Avoid returning pointer to automatic vars

Don’t keep pointers to vars in inner blocks



39

Casting pointersCasting pointers

Converting between pointer types is riskyCompiler will warn – Coercion possible



40

Void*Void*

Pointer type used to represent addresses without any type information

Shouldn’t be dereferencedProgrammer responsible for coercion



41

Const pointersConst pointers



42

Pointers to pointersPointers to pointers



43




44




45




46

Pointer ArithmeticPointer Arithmetic

C permits addition/subtraction on pointersIncrements correspond to size of type value

Effective with contiguous set of variables



47

Pointers to array elementsPointers to array elements

Pointers can aimat address of array elements

Refer to other elements withpointer arithmetic



48

Array variable often treated as ptr to 1st elementActually not a pointerComputes into an rvalue

for assignment to pointer

Passable to function that takes pointer or array

Not reassignableSizeof(ar) returns array

size

The array “Variable”The array “Variable”



49

Dynamic Memory Allocation

Background DynamicPointersIntro to Pointers and Memory in C

50

Why do we need to allocate Why do we need to allocate memory?memory?Size of data may not be known in

advanceMay depend on user input

e.g., Input N, then get N numbers, then present sorted

May depend on result of calculationSize may change over time

e.g., Increase canvas size or number of pages

Intro to Pointers and Memory in C Background DynamicPointers

51

Why do we need to allocate Why do we need to allocate memory?memory?Global and automatic arrays can only be declared with compile-time constant size(Relaxed in C99)


52

Why do we need to allocate Why do we need to allocate memory?memory?We want to control lifetime of data

stored over timeLive after function endsDie before program terminates

Basis for most data structures


53

How do we allocate memory?How do we allocate memory?

void *malloc(size_t size);Submits request to allocate contiguous block of

given size.Size often specified as n*sizeof(type)If failed, returns NULLIf valid, returns void pointer to new memory areaProgrammer converts into pointer to first

elementPointer arithmetic or subscripts access rest of

spaceNo bounds checking!

NULL otherwiseIntro to Pointers and Memory in C Background DynamicPointers

54

The heapThe heap

A memory area provided to the process for allocating dataOften limited

Runtime tracks where all memory is allocatedEvery allocation is contiguous

Possibility of fragmentation even if enough total free space

No way to check in advance


55

Allocated memory must be freed!Allocated memory must be freed!

Programmer responsible for releasing dynamically allocated memory ASAP.Use free() operation

void free(void *ptr);System will know how much space to clear

Failure to free causes memory leak


56

Malloc/Free exampleMalloc/Free example


57

free() caveatsfree() caveats

Do not free a pointer prematurelyMake sure it will not be accessed again via other pointer!

All other pointers are dangling references


58


Once pointer to memory is lost, no way to free it

Do not release pointer to middle of allocated region


59


Freeing the same memory twiceFreeing an automatic variable


60

Summary of covered topicsSummary of covered topics

MemoryAddress space necessary to understand pointers

Storage of large valuesImplementation of variables and calls

Lifetime and effect on pointer validityNeed for pointers

Pointers and their risksPointer arithmetic and relation to arraysNeed and risk of dynamic allocation


61

Questions?

62

Backup materials


63

Topics not coveredTopics not covered

Pointers to pointersFunction pointersStructsFar pointers

64

Do not rely on stack organization!Do not rely on stack organization!

65

Pointers can be comparedPointers can be compared

66

Caveats – Dangling referencesCaveats – Dangling references

Do not keep pointers to dying variables

67

Null-terminated stringsNull-terminated strings

Strings: Array of chars terminated by ‘\0’ or 0.String can take less space than actual array

sizeSince \0 can come early…

Missing the \0 will lead many functions past allocated memory

Storage depends on actual assignment

68

Global VariablesGlobal Variables

Variables can be declared outside functionsAccessible from everywhereInitialized before main() startedLive until program terminatesFunction static variables can be thought of as

global

Technology

Introduction to pointers and memory management in C