pointers and arrays - agh university of science and technologygawronski/2019_pp/lecture_08.pdf ·...

Pointers and arrays

Lecture 8

November 26, 2019

(Lecture 8) Pointers and arrays November 26, 2019 1 / 19

Outline

1 Pointersusing array name as a pointerusing pointer as array name

2 Dynamic storage allocation

3 Memory leak

Pointers - combining ∗ and ++ operators

C programmers often combine the * and ++ operators in statementsthat process array elements.

int a[10], i = 0, j = 10, *p = &a[0];

a[i++] = j;*p++ = j;

expression meaning*p++ or *(p++) value of expression is *p before increment

increment p later(*p)++ value of expression is *p before increment

increment *p later*++p or *(++p) increment p first

value of expression is *p after increment++*p or ++(*p) increment *p first

value of expression is *p after increment

int a[10], i = 0, j = 10, *p = &a[0];

a[i++] = j;*p++ = j;

int a[10], i = 0, j = 10, *p = &a[0];

a[i++] = j;*p++ = j;

Pointers - comparing pointers

Using relational operators to compare two pointers is meaningful onlywhen both point to elements of the same array.

The outcome of the comparison depends on the relative positions ofthe two elements in the array.

#define SIZE 10

int sump(int *start , int *end) {int total = 0;while (start < end)

total += *start ++;return total;

}...int tab[SIZE] = {20,10,5,39,4 ,16 ,19 ,26 ,31 ,20};int sum = sump(&tab[0], &tab[SIZE]);

#define SIZE 10

int a[SIZE], total = 0, *p = &a[0];for(;p<&a[SIZE]; p++)

total += *p;

Using &a[SIZE] in the for condition is perfectly safe, since the loopdoesn’t attempt to examine its value.

The loop terminates when p is equal to &a[SIZE].

#define SIZE 10

total += *p;

#define SIZE 10

total += *p;

Pointers - using array name as a pointer

Pointer arithmetic is one way in which arrays and pointers are related.

The name of an array can be used as a pointer to the first element inthe array.This relationship simplifies pointer arithmetic and makes both arraysand pointers more versatile.

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

a+i is the same as &a[i] - both represent a pointer to element i of a.*(a+i) is the same as a[i] - both represent element i itself.Array subscripting can be viewed as a form of pointer arithmetic.

#define SIZE 10int a[SIZE], total = 0, *p = a;for(;p < a + SIZE; p++)

total += *p;

Pointer arithmetic is one way in which arrays and pointers are related.The name of an array can be used as a pointer to the first element inthe array.

This relationship simplifies pointer arithmetic and makes both arraysand pointers more versatile.

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

total += *p;

Pointer arithmetic is one way in which arrays and pointers are related.The name of an array can be used as a pointer to the first element inthe array.This relationship simplifies pointer arithmetic and makes both arraysand pointers more versatile.

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

total += *p;

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

total += *p;

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

a+i is the same as &a[i] - both represent a pointer to element i of a.

*(a+i) is the same as a[i] - both represent element i itself.Array subscripting can be viewed as a form of pointer arithmetic.

total += *p;

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

a+i is the same as &a[i] - both represent a pointer to element i of a.*(a+i) is the same as a[i] - both represent element i itself.

Array subscripting can be viewed as a form of pointer arithmetic.

total += *p;

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

total += *p;

int a[10];

*a = 12; //a[0]=12;*(a+1) = 16; //a[1]=16;

total += *p;(Lecture 8) Pointers and arrays November 26, 2019 6 / 19

#define SIZE 8

int itab[SIZE], *pit=itab; //int *pit=&itab [0];double dtab[SIZE], *pdt=dtab;printf("%18s %15s\n", "int", "double");for (int i = 0; i < SIZE; i++)printf("ptr + %d %10p %10p\n", i, pit+i, pdt+i);

int doubleptr + 0 : 0x7fff36430c60 0x7fff36430c10ptr + 1 : 0x7fff36430c64 0x7fff36430c18ptr + 2 : 0x7fff36430c68 0x7fff36430c20ptr + 3 : 0x7fff36430c6c 0x7fff36430c28ptr + 4 : 0x7fff36430c70 0x7fff36430c30ptr + 5 : 0x7fff36430c74 0x7fff36430c38ptr + 6 : 0x7fff36430c78 0x7fff36430c40ptr + 7 : 0x7fff36430c7c 0x7fff36430c48

#define SIZE 8

int itab[SIZE], *pit=itab; //int *pit=&itab [0];double dtab[SIZE], *pdt=dtab;printf("%18s %15s\n", "int", "double");for (int i = 0; i < SIZE; i++)printf("ptr + %d %10p %10p\n", i, pit+i, pdt+i);

int doubleptr + 0 : 0x7fff36430c60 0x7fff36430c10ptr + 1 : 0x7fff36430c64 0x7fff36430c18ptr + 2 : 0x7fff36430c68 0x7fff36430c20ptr + 3 : 0x7fff36430c6c 0x7fff36430c28ptr + 4 : 0x7fff36430c70 0x7fff36430c30ptr + 5 : 0x7fff36430c74 0x7fff36430c38ptr + 6 : 0x7fff36430c78 0x7fff36430c40ptr + 7 : 0x7fff36430c7c 0x7fff36430c48

Pointers - using pointer as array name

We can use an array name as a pointer, we can use a pointer as if itwere an array name.

#define SIZE 10int a[SIZE], i = 0, total = 0, *p = a;for(;i < SIZE; i++)

total += p[i];

The compiler treats p[i] as *(p+i).

The compiler treats *(p+i) and *(i+p) the same, so ...

if *(p+i) is the same as p[i], then

if *(i+p) is the same as i[p].

Notation i[p] is perfectly correct but not recommended.

total += p[i];

Dynamic storage allocation

C’s data structures are fixed in size.

In C99, the length of a variable-length array is determined at runtime, but it remains fixed for the rest of the array’s lifetime.

C supports dynamic storage allocation - the ability to allocate storageduring program execution.

Using dynamic storage allocation, we can design data structures thatgrow (or shrink) as needed.

Dynamic storage allocation is used most often for strings, arrays andstructures.

Dynamically allocated structures are of particular interest, since wecan link them together to form lists, trees, and other data structures.To allocate storage dynamically, we’ll need to call one of the threememory allocation functions declared in the <stdlib.h> header:

malloc - allocates a block of memory but doesn’t initialize it,calloc - allocates a block of memory and clears it,realloc - resizes a previously allocated block of memory.

Dynamically allocated structures are of particular interest, since wecan link them together to form lists, trees, and other data structures.

To allocate storage dynamically, we’ll need to call one of the threememory allocation functions declared in the <stdlib.h> header:

Dynamically allocated structures are of particular interest, since wecan link them together to form lists, trees, and other data structures.To allocate storage dynamically, we’ll need to call one of the threememory allocation functions declared in the <stdlib.h> header:malloc - allocates a block of memory but doesn’t initialize it,

calloc - allocates a block of memory and clears it,realloc - resizes a previously allocated block of memory.

Dynamically allocated structures are of particular interest, since wecan link them together to form lists, trees, and other data structures.To allocate storage dynamically, we’ll need to call one of the threememory allocation functions declared in the <stdlib.h> header:malloc - allocates a block of memory but doesn’t initialize it,calloc - allocates a block of memory and clears it,

realloc - resizes a previously allocated block of memory.

Dynamically allocated structures are of particular interest, since wecan link them together to form lists, trees, and other data structures.To allocate storage dynamically, we’ll need to call one of the threememory allocation functions declared in the <stdlib.h> header:malloc - allocates a block of memory but doesn’t initialize it,calloc - allocates a block of memory and clears it,realloc - resizes a previously allocated block of memory.

When we call a memory allocation function to request a block ofmemory, the function has no idea what type of data we’re planning tostore in the block.

The function returns the memory address in the generic pointer typevoid *.

If the allocation cannot be made, the function returns a null pointer.

It’s the programmer’s responsibility to test the return value of anymemory allocation function and take appropriate action if it’s a nullpointer.

The effect of attempting to access memory through a null pointer isundefined, the program may crash.

Always use sizeof when calculating how much space is needed for anarray.

#include <stdlib.h>float *p = malloc (100* sizeof(float));

if (!p){ //if (p == NULL) {// allocation failed; take appropriate action}else {// allocation successful}

if (p){ //if (p != NULL) {// allocation successful}else{// allocation failed; take appropriate action}

#include <stdlib.h>float *p = malloc (100* sizeof(float));

if (!p){ //if (p == NULL) {// allocation failed; take appropriate action}else {// allocation successful}

if (p){ //if (p != NULL) {// allocation successful}else{// allocation failed; take appropriate action}

After allocating the memory, calloc initializes it by setting all bits to0.

#include <stdlib.h>

double *p = calloc (100, sizeof(double));

if (p){...}

The realloc function can resize the array - void *realloc( void *ptr,size t size);ptr - must point to a memory block obtained by a previous call ofmalloc, calloc or realloc.The size parameter represents the new size of the block, which maybe larger or smaller than the original size.

#include <stdlib.h>

if (p){...}

#include <stdlib.h>

if (p){...}

The realloc function can resize the array - void *realloc( void *ptr,size t size);

ptr - must point to a memory block obtained by a previous call ofmalloc, calloc or realloc.The size parameter represents the new size of the block, which maybe larger or smaller than the original size.

#include <stdlib.h>

if (p){...}

The realloc function can resize the array - void *realloc( void *ptr,size t size);ptr - must point to a memory block obtained by a previous call ofmalloc, calloc or realloc.

The size parameter represents the new size of the block, which maybe larger or smaller than the original size.

#include <stdlib.h>

if (p){...}

Rules concerning behavior of realloc:

When it expands a memory block, realloc doesn’t initialize the bytesthat are added to the block.If realloc can’t enlarge the memory block as requested, it returns anull pointer, the data in the old memory is unchanged.If realloc is called with a null pointer as its first argument, it behaveslike malloc.If realloc is called with 0 as its second argument, it frees the memoryblock.

Example.

int n=150, b=18;

int *tab = realloc(NULL , n * sizeof(int));tab = realloc(tab , (n - b) * sizeof(int));tab = realloc(tab , (2*n + 7*b) * sizeof(int));tab = realloc(tab , 0);

Rules concerning behavior of realloc:When it expands a memory block, realloc doesn’t initialize the bytesthat are added to the block.

If realloc can’t enlarge the memory block as requested, it returns anull pointer, the data in the old memory is unchanged.If realloc is called with a null pointer as its first argument, it behaveslike malloc.If realloc is called with 0 as its second argument, it frees the memoryblock.

Example.

int n=150, b=18;

Rules concerning behavior of realloc:When it expands a memory block, realloc doesn’t initialize the bytesthat are added to the block.If realloc can’t enlarge the memory block as requested, it returns anull pointer, the data in the old memory is unchanged.

If realloc is called with a null pointer as its first argument, it behaveslike malloc.If realloc is called with 0 as its second argument, it frees the memoryblock.

Example.

int n=150, b=18;

Rules concerning behavior of realloc:When it expands a memory block, realloc doesn’t initialize the bytesthat are added to the block.If realloc can’t enlarge the memory block as requested, it returns anull pointer, the data in the old memory is unchanged.If realloc is called with a null pointer as its first argument, it behaveslike malloc.

If realloc is called with 0 as its second argument, it frees the memoryblock.

Example.

int n=150, b=18;

Rules concerning behavior of realloc:When it expands a memory block, realloc doesn’t initialize the bytesthat are added to the block.If realloc can’t enlarge the memory block as requested, it returns anull pointer, the data in the old memory is unchanged.If realloc is called with a null pointer as its first argument, it behaveslike malloc.If realloc is called with 0 as its second argument, it frees the memoryblock.

Example.

int n=150, b=18;

Rules concerning behavior of realloc:When it expands a memory block, realloc doesn’t initialize the bytesthat are added to the block.If realloc can’t enlarge the memory block as requested, it returns anull pointer, the data in the old memory is unchanged.If realloc is called with a null pointer as its first argument, it behaveslike malloc.If realloc is called with 0 as its second argument, it frees the memoryblock.

Example.

int n=150, b=18;

malloc and the other memory allocation functions obtain memoryblocks from a storage pool known as the heap.

Each C program is responsible for recycling its own garbage by callingthe free function to release unneeded memory.

Using free is easy:

#include <stdlib.h>

int *t = malloc( n * sizeof(int) );...free (t);

Calling free releases the block of memory that t points to.

This block is now available for reuse in subsequent calls of malloc,calloc or realloc.

Using free is easy:

#include <stdlib.h>

Using free is easy:

#include <stdlib.h>

Using free is easy:

#include <stdlib.h>

Using free is easy:

#include <stdlib.h>

Storage allocation: stack vs. heap

Never return a pointer to an automatic local variable from the stack:

int *BAD_get_tab(int var){int local_tab[SIZE];for(int i=0; i<SIZE; i++)

local_tab[i] = fun(var);return local_tab;

}int main(void){

int *ltab = BAD_get_tab (3);return 0;

gcc lcaltab.c -Walllcaltab.c:9:3: warning: function returns address of local variable[-Wreturn-local-addr]return local tab;

Storage allocation: stack vs. heap

Allocation and deallocation of the array on the heap:

int *array_malloc(int var , int n){int *pt;if (pt = malloc(n * sizeof(int)) ){

for(int i=0; i<n; i++)pt[i] = fun(var);

}return pt;

}int main(void){

int *mtab = array_malloc (6, 1000);...free(mtab);return 0;

Memory leak

int *p = malloc (100 * sizeof(int));int *q = malloc (100 * sizeof(int));

A program may allocate blocks of memory and then lose track ofthem.

Memory leak

int *p = malloc (100 * sizeof(int));int *q = malloc (100 * sizeof(int));

A program may allocate blocks of memory and then lose track ofthem.

Memory leak

int *p = malloc (100 * sizeof(int));int *q = malloc (100 * sizeof(int));p=q;

After q is assigned to p, both variables now point to the secondmemory block.

There are no pointers to the first memory block, so we’ll never beable to use it.

Garbage - a block of memory that’s no longer accesible to a program.

Memory leak

A program that leaves garbage behind has a memory leak.

C doesn’t provide a garbage collector that automatically locates andrecycles garbage.

http://valgrind.org/ - Valgrind is an instrumentation framework forbuilding dynamic analysis tools. There are Valgrind tools that canautomatically detect many memory management bugs.

Memory leak

pointers and arrays - agh university of science and technologygawronski/2019_pp/lecture_08.pdf ·...

Documents