Lecture 3 Memory and Pointers

Transcription

1 Lecture 3 Memory and Pointers

2 Lets think about memory We can think of memory as a series of empty slots Each cell in the slot will hold 1 Byte To identify which cell something is in we need an identifier. This is called a memory address This is allocated by the OS when we communicate with it that we need a memory slot

3 Remember this? sizeof( data type) sizeof(char)= 1 sizeof(short int)= 2 sizeof(int)= 4 sizeof(long int)= 8 unsigned versions sizeof(unsigned char)= 1 sizeof(unsigned short int)= 2 sizeof(unsigned int)= 4 sizeof(unsigned long int)= 8 this tells us how many 1 byte memory cells each data type uses

4 #include <stdio.h> #include <stdlib.h> int main() { printf("sizeof(char)= %ld \n",sizeof(char)); printf("sizeof(short int)= %ld \n",sizeof(short int)); printf("sizeof(int)= %ld \n",sizeof(int)); printf("sizeof(long int)= %ld \n",sizeof(long int)); printf("unsigned versions\n"); printf("sizeof(unsigned char)= %ld \n",sizeof(unsigned char)); printf("sizeof(unsigned short int)= %ld \n",sizeof(unsigned short int)); printf("sizeof(unsigned int)= %ld \n",sizeof(unsigned int)); printf("sizeof(unsigned long int)= %ld \n",sizeof(unsigned long int)); } return EXIT_SUCCESS; sizeof(char)=1 Memory Cell Block sizeof(short int)=2 sizeof(int)=4 sizeof(long int)=8 sizeof(float)=4 sizeof(double)=8

5 & the address operator Sometimes know as a reference operator will give us the memory address of the cell containing the value we can usually use & to print it out. #include <stdio.h> #include <stdlib.h> int main() { int i=0; char c='c'; double d=1.0; float f=1.0; printf("i address is %p \n",&i); printf("c address is %p \n",&c); printf("d address is %p \n",&d); printf("f address is %p \n",&f); address of i is 0x7fff52ebc72c address of c is d address of c is 0x7fff52ebc72b address of d is 0x7fff52ebc720 address of f is 0x7fff52ebc71c } return EXIT_SUCCESS;

6 Storage Areas When a program is executed three storage areas are created called segments. Text / Code Segment :- used for the machine code / program instructions including functions. Data Segment (Data + Block Started Symbol + Heap) The Stack Segment :- used for all variables / function variables executed in main

7 High address Command line args argv[0].. argv[n] Stack user Heap BSS Segment Program Data Data Segment Text Segment Program Code kernel OS Kernel (read only) low address

8 Text / Code segment This is where the machine code generated by the compiler lives It is a fixed size (size of our program) and generally read only Usually if an attempt is made to modify data in this segment the program will core dump It is possible to make this position independent for use in shared libraries / DLL s

9 Data Segment BSS Block Started by Symbol This is where global (declared outside main) data that is not assigned a value is stored Also any data prefixed with static and not assigned a default value By default this is assigned zero unless given a default value

10 Data Segment Any data that either global or static but has a predefined value is allocated in the data segment int global1=1; int global2; static float PI=3.141 int main() { static int i=0; static int x; BSS Segment Data Segment set to 0 set to assigned value

11 Stack The stack is where local variables are allocated (automatic variables) This is denoted by the { for scope The data is popped or pushed into the stack following the Last In First Out(LIFO) rule The stack is also used to hold information about functions such as return values and parameters passed (more later) We have little control over the stack

12 Stack Frames When a program calls a function, the function and it s arguments / return point are placed on a stack The function being called may also need local variables to be created on the stack so it will store the initial stack pointer as a frame pointer

13 Stack Pointer main() main () stack frame

14 Stack Pointer return value args main() main () stack frame When we call foo main pushes the arguments for foo onto the stack

15 Stack Pointer foo() foo () stack frame Frame Pointer return value args foo now has a stack for local variables main() main () stack frame Once we have finished foo we replace the stack pointer with the frame pointer

16 stack trace void trace() { void* callstack[128]; int frames = backtrace(callstack, 128); char** strs = backtrace_symbols(callstack, frames); for (int i = 0; i < frames; ++i) { std::cout<<strs[i]<<"\n"; } free(strs); }

17 ./a.out 0 a.out 0x a71f03a _Z5tracev a.out 0x a71f169 main libdyld.dylib 0x00007fff8961b5c9 start + 1 in foo trace() 0 a.out 0x a71f03a _Z5tracev a.out 0x a71f144 _Z3foov a.out 0x a71f16e main libdyld.dylib 0x00007fff8961b5c9 start + 1 in bar trace() 0 a.out 0x a71f03a _Z5tracev a.out 0x a71f11a _Z3bari a.out 0x a71f14e _Z3foov a.out 0x a71f16e main libdyld.dylib 0x00007fff8961b5c9 start + 1

18 recursion A recursive function is a function that can call itself Typical examples are things like calculating factorials or traversing tree like structures It is possible to get a stack overflow using these types of functions

19 int fact( int n ) { trace(); if ( n == 0 ) return 1 ; else return fact( n - 1 ) * n ; } int main() { fact(-1); } 116 a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti a.out 0x ef8 _Z4facti + 56 Segmentation fault: 11

20 Heap The heap is used for the programmer to define dynamic memory Data on the heap is anonymous (i.e. not linked to a variable) and the only way we can access it is via a memory address The programmer will then have to manage this data and is one of the most important parts of programming in a non managed language such as C/C++

21 Example Program #include <stdio.h> #include <stdlib.h> int globalvar=0; int func(int _add) { static int stat=0; return stat+=_add; } int main() { int local=0; int i; for(i=0; i<10; ++i) { printf("static = %02d local= %02d global = %02d \n", func(i),local++,globalvar++ ); } return EXIT_SUCCESS; }

22 Program Execution Code Segment.globl _globalvar.zerofill DATA, common,_globalvar,4,2.zerofill DATA, bss,_stat.2777,4,2.section TEXT, cstring,cstring_literals.align 3 L_.str:.asciz "static = %02d local= %02d global = %02d \n".section TEXT, eh_frame,coalesced,no_toc+ strip_static_syms+live_support EH_frame0: Lsection_eh_frame: Leh_frame_common: Lset0 = Leh_frame_common_end-Leh_frame_common_begin.long Lset0 Leh_frame_common_begin:.long 0.byte 1.asciz "zr".byte 1.byte 120.byte 16.byte 1.byte 16.byte 12.byte 7.byte 8.byte 144.byte 1.align 3 Leh_frame_common_end:

23 Arrays Simple data types use a single memory cell to store a variable. It is sometimes more efficient to group data items together in main memory than to allocate an individual memory cell for each variable. A simple way to different fixed amounts of the same data type is by the use of an array. An array is a collection of two or more adjacent cells called array elements associated with a specific symbolic name

24 Array declaration double x[8]; The command above instructs the compiler to allocate 8 double memory cells of type double. These cells will be contiguous (next to each other in a continuous block) This mean accessing them can be done in a sequential manner To access the cells we use an index into the cells starting a 0 for the first index.

25 Array Access To access elements of the array we use the subscript operator [ ] This can be used to get or set the array index value as shown x[0] x[1] x[2] x[3] x[4] x[5] x[6] x[7]

26 Array Manipulation Statement Explanation printf("%.1f ",x[0]); Display the value of x[0] which is 16.0 x[3]=25.0; sum=x[0]+x[1]; sum+=x[2]; x[3]+=1.0 x[2]=x[0]+x[1] Store the value 25.0 in x[3] Store the sum of element x[0] and x[1] into the variable sum Adds x[2] to sum Adds 1 to x[3] Stores the sum of x[0] and x[1] into x[2]

27 Array Initialisation #include <stdio.h> #include <stdlib.h> We can initialise an array in a similar way to a normal variable, the code opposite show this int main() { // array of vowels char vowels[5]={'a','e','i','o','u'}; // the compiler will fill in how many values (25) int primeslt100[]={2,3,5,7,11,13,17,19,23,29,31, 37,41,43,47,53,59,61,67,71,73, 79,83,89,97}; // index to our array int i; // loop and print out the values for(i=0; i<5; ++i) { printf("%c ",vowels[i]); } // newline printf("\n"); // as we don't know how big the primes array is we need // to figure it out, sizeof will return how big the allocated // space is, however it is in bytes and an int takes up // sizeof(int) (usually 4) bytes so we need to div by this } int sizeofarray=sizeof(primeslt100)/sizeof(int); printf("size of array %d\n",sizeofarray); // loop and print for(i=0; i<sizeofarray; ++i) { printf("%d ",primeslt100[i]); } printf("\n"); return EXIT_SUCCESS;

28 Multi-dimensional arrays We can use multi-dimensional arrays to store data in table / tabular format. Whilst this is quite useful for many applications it is still usually more efficient to use a single dimensional array (more in future lectures) The format for declaration is as follows element-type name[size1] [size2]... [sizen];

29 Example If we wished to create an array to store the data for a game of noughts and crosses (tic tac toe for Americans!) We could do the following char XO[3][3]; Column Row 0 X O X 1 O X O XO[1][2] 2 O X X

30 initialising array #include <stdio.h> #include <stdlib.h> int main() { char XO[3][3]={ }; {'-','-','-'}, {'-','-','-'}, {'-','-','-'}, Init all array elements to a - XO[1][2]='O'; int x,y; for(y=0; y<3; ++y) { for(x=0; x<3; ++x) { printf("%c ",XO[y][x]); } printf("\n"); } O } return EXIT_SUCCESS;

31 You can get silly #include <stdio.h> #include <stdlib.h> int main() { int array[4][12][23][5][9][2]; array[0][1][2][3][1][0]=10; printf("%d\n",array[0][1][2][3][1][0]); } return EXIT_SUCCESS; But not recommended!

32 What is a pointer? It's a variable just like any other variable The pointer variable is defined by the asterisk * being placed before the variable name. int *wholenum; What did that just say? Well the variable wholenum is a pointer of type int.

33 But why use Pointers? C and C++ allow the programmer to point into a program and at memory Pointers point to a memory address where a declared variable lives This allows us to create and manipulate dynamic data structures which can grow or shrink depending upon the program need. It also lets us allocate memory on the fly within a program.

34 Pointers and Arrays In C, there is a strong relationship between pointers and arrays, strong enough that pointers and arrays should be discussed simultaneously. Any operation that can be achieved by array subscripting can also be done with pointers. The pointer version will in general be faster but, at least to the uninitiated, somewhat harder to understand. The C Programming Language K&R

35 Pointers and Arrays int a[10]; The definition above declares and array of integers size 10

36 Pointers and Arrays int *pa; pa = &a[0]; The assignment sets pa to point to element zero of a; that is, pa contains the address of a[0].

37 Pointers and Arrays In declarations, [ ] means array of and means pointer to. The assignment x = *pa; will copy the contents of a[0] into x.

38 Pointers and Arrays If pa points to a particular element of an array, then by definition pa+1 points to the next element, pa+i points i elements after pa, and pa-i points i elements before. Thus, if pa points to a[0], *(pa+i) refers to the contents of a[1], pa+i is the address of a[i], and *(pa+i) is the contents of a[i].

39 Pointers and Arrays a reference to a[i] can also be written as *(a+i). In evaluating a[i], C converts it to *(a+i) immediately; the two forms are equivalent. Applying the operator & to both parts of this equivalence, it follows that &a[i] and a+i are also identical: a+i is the address of the i-th element beyond a.

40 What really happens when we create a pointer? Normally a variable directly contains a specific value A pointer contains the (memory) address of a variable that contains a specified value A variable name directly references a value and a pointer indirectly references a value Referencing a value through a pointer is called indirection

41 Remember the Cells? A pointer is used to hold a memory address Whilst all memory address sizes are the same for an operating system The cell size is dependant upon the data type we are pointing to. Hence we give it a data type (int, char float etc) As this will automatically determine the size of the cell we need to manage.

42 int count 4 count directly references a variable whose value is 4 int *countptr int count 4 countptr indirectly references a variable whose value is 4.

43 A simple example #include <stdio.h> #include <stdlib.h> int main() { int i; int *ptri; i=5; printf("i given the value 5 directly i=%d \n",i); // ptri now points to i ptri=&i; // now assign via the indirection *ptri=10; printf("now using the pointer ptri now equals %d\n",i); } return EXIT_SUCCESS;

44 What did that code do? Firstly two variables are declared i a normal integer and *ptri which is a pointer to an integer The first assignment i=5 directly assigned i with the value 5. The second assignment ptri=&i says store the address of the variable i into the variable ptri The final assignment *ptri=10; tells the program to put the value 10 into the memory address pointed to by ptri confused?... Lets look at some pictures

45 With Pictures ptri=&i; 0x100 i 0x102 ptri 0x102 0x104 0x106 0x108 0x10A

46 With Pictures *ptri=10; 0x100 i 10 0x102 ptri 0x102 0x104 0x106 0x108 0x10A

47 void pointers So far we've looked at pointers of the same type e.g. *ptri=i; where both are of type int However this is sometimes not practical So we can use pointers of type void These can assume any data type (with a little help using a process called coercion)

48 A void Pointer Example #include <stdio.h> #include <stdlib.h> int main() { // variables to hold our values int i; char c; float f; // our void pointer void *ptrmorph; // point our pointer to i ptrmorph = &i; *((int *)ptrmorph) =10; i=10 c=c f= // point our pointer to c ptrmorph =&c; *((char *)ptrmorph)='c'; // point our pointer to f ptrmorph=&f; *((float *)ptrmorph)= 25.45f; printf("i=%d c=%c f=%f\n",i,c,f); return EXIT_SUCCESS; }

49 (What (are) all those brackets) for (?) As mentioned we have to tell the pointer what data type we mean it to assume to do this we need the brackets (1) I m a Pointer (2) A float pointer (4)So assign it a value of 25.45f *((float *)ptrmorph)=25.45f; (3)allthough ptrmorph is of type void * I m forcing it to be a float value

50 Why does this work? Remember the cells and the sizeof things! sizeof(void) = 8 (on my 64 bit machine) This is the size of a memory address With the casting we basically get the memory address (always the same size) but take into account the cell size for the actual data type. But why does this matter?

51 Well we can do arithmetic with pointers! YES WE CAN DO MATHS WITH POINTERS! This can lead to confusion however is really powerful and allows us lots of flexibility in coding.

52 Variable Arithmetic Arithmetic on normal variables changes the value contained in the variable This is shown in the following table variable initializer operation result int i=0; i++; i=1 int i=5; i+=5; i=10 int i=10; i--; i=9 int i=10; i-=5; i=5

53 Pointer Arithmetic Arithmetic with pointers take the same form as with other variables as shown #include <stdio.h> #include <stdlib.h> int main() { int intarray[5]={32,65,1,399,9324}; int *ptrtoarray; // as we are using an array we could use // ptrtoarray=intarray; however the following is // more clear when getting the first element ptrtoarray=&intarray[0]; // i for loop for (int i=0; i<5; i++) { printf("intarray value = %d \n",*ptrtoarray); printf("ptrtoarray address= %p \n",ptrtoarray); // increment the pointer to next cell ptrtoarray++; } } return EXIT_SUCCESS;

54 output intarray value = 32 ptrtoarray address= 0x7fff6047d1d4 intarray value = 65 ptrtoarray address= 0x7fff6047d1d8 intarray value = 1 ptrtoarray address= 0x7fff6047d1dc intarray value = 399 ptrtoarray address= 0x7fff6047d1e0 intarray value = 9324 ptrtoarray address= 0x7fff6047d1e4 memory address increments sizeof(int) each time ptrtoarray++ is executed

55 Dynamic memory Allocation When we dynamically allocate memory in a C program we allocate to the heap. This means that the data will be persistent throughout the program lifetime. This means we have to manage this memory ourselves. As the OS allocates the memory for us it is possible that we can run out of memory

56 example #include <stdio.h> #include <stdlib.h> int main() { char *mem; mem=malloc( ); free(mem); return EXIT_SUCCESS; } a.out(33799) malloc: *** mmap(size= ) failed (error code=12) *** error: can't allocate region *** set a breakpoint in malloc_error_break to debug

57 malloc To allocate memory in C we use malloc This allocates size bytes of memory. If the allocation succeeds, a pointer to the block of memory is returned. malloc returns a void pointer (void *), which indicates that it is a pointer to a region of unknown data type. #include <stdlib.h> void * malloc(size_t size); NULL is returned if memory can t be allocated

58 free The memory created by malloc is persistent so needs to be cleared once finished with. This is done with the free function as follows #include <stdlib.h> void free(void *ptr); The pointer must be passed to free only once; unless malloc has been re-called on the same pointer.

59 #include <stdio.h> #include <stdlib.h> Example int main() { char *mem; mem=malloc(10); // free mem free(mem); // double free error free(mem); } return EXIT_SUCCESS; a.out(39525) malloc: *** error for object 0x104a00840: pointer being freed was not allocated *** set a breakpoint in malloc_error_break to debug Abort trap: 6

60 malloc / free The implementation of malloc is not guaranteed to initialise the memory to a set value This can lead to security flaws where we can re-allocate memory and see previous values. In the case of the gcc implementation it seems that the values are set to a zero memory is always allocated contiguously so it can be accessed in the same way as an array as shown in the following example.

61 #include <stdio.h> #include <stdlib.h> int main() { float *mem; mem=malloc(20); for (int i=0; i<20; ++i) { printf("%f ",mem[i]); } printf("\n"); // free up the memory free(mem); return EXIT_SUCCESS; }

62 calloc malloc does not initialise the memory (gcc however does seem to do so) The calloc function however is designed to both allocate memory and set it to zero. #include <stdlib.h> void *calloc(size_t count,size_t size); It allocates count bytes with size data type size float *f = calloc(20,sizeof(float));

63 realloc The realloc function allows us to resize already allocated memory. We can shrink or grow this memory space #include <stdlib.h> void *realloc(void *ptr,size_t size); If realloc is unable to resize the memory region in-place, it allocates new storage then copies the required data. The old pointer is then freed If realloc fails it returns a NULL but the original memory is unaffected

64 #include <stdio.h> #include <stdlib.h> int main() { int index=0; // allocate some memory char *alphabet = calloc(26,sizeof(char)); allocate memory for chars a-z for( char c='a'; c<='z'; ++c) { alphabet[index++]=c; } } for(int i=0; i<26; ++i) { printf("%c ",alphabet[i]); } printf("\nrealloc \n"); alphabet=realloc(alphabet,26*2); for( char c='a'; c<='z'; ++c) { alphabet[index++]=c; } for(int i=0; i<26*2; ++i) { printf("%c ",alphabet[i]); } printf("\n"); return EXIT_SUCCESS; now re-allocate twice as much put upper-case chars in, as index has not change it carries on from where it left off

65 memset #include <string.h> void *memset(void *b int c, size_t len); The memset function set writes len bytes of value c (converted to an unsigned char) to string b It performs a byte to byte copy

66 memcpy #include <string.h> void *memcpy(void *dst, void *src, size_t len); The memcpy function copies len bytes from memory area src to memory area dst. If src and dst over-lap, behaviour is undefined.

67 References Hanly. J. R Koffman E. B. 1999, Problem Solving & Program Design in C, 3rd Edition, Addison Wesley, International Ed Sebesta R. W. 2002, Concepts of Programming Languages, 5th edition, Addison Wesley, International Ed