This presentation is the property of its rightful owner.
1 / 19

# Math 130 Introduction to Computing Arrays and Pointers Lecture # 16 PowerPoint PPT Presentation

B Smith: 10-13-04: More pictures needed. Too wordy. Length is about right if going to the board. B Smith:. B Smith: 3/11/2005 11:33 AM: Rate 3: focus more on code. Change integer as 2 bytes to integer as 4 bytes! Consider putting in dark format.

Math 130 Introduction to Computing Arrays and Pointers Lecture # 16

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

#### Presentation Transcript

B Smith:

10-13-04:

More pictures needed. Too wordy. Length is about right if going to the board.

B Smith:

B Smith:

3/11/2005 11:33 AM: Rate 3: focus more on code. Change integer as 2 bytes to integer as 4 bytes! Consider putting in dark format

## Math 130Introduction to ComputingArrays and PointersLecture # 16

B Smith:

10/17/05: 3.5/4. Time: 50 min.

### Learning Objectives

• Array Names as Pointers (§8.1)

• Indirect referencing: Convert integer array notation to pointer notation

• Pointer Arithmetic (§8.2)

• Use pointers vs indices for array processing

• Passing and Using Array Addresses (§8.3)

• Use pointer declaration vs standard as a function argument vs standard array declaration

### Array Name as A Pointer

• Pointers are closely associated with array names

• Subscripts are related to the true address of an array element

• The array element’s address is determined from the address of the first element, and the size of the element

• Given grades[4], and that an integer is stored as four bytes, the computer calculates the address as:

&grades[4] = &grades[0] + (4 * 4(bytes) )

address of first element plus an 16 byte offset (1 int = 4 bytes)

0xA201

0xA205

0xA209

0xA20C

### Pointer Arithmetic

• Used to calculate the address of any array element

• If each integer takes up 4 bytes of memory, the address of grades[2] can be calculated from the address of grades[0] plus 8

### Using Pointers to Access Array Elements

• We can create a pointer to store the address of the first array element

• an array of integers requires an int*

• an array of characters requires a char*

• This allows us to access any individual element in the array using the pointer

int myArray[4];

int* arrPtr;

arrPtr = &myArray[0];

char myNames[20];

char* charPtr;

charPtr = &myNames[0];

### pgm 8.1

Without using pointers

#include <stdio.h>

int main()

{

int i;

int grades[] = {98, 87, 92, 79, 85};

for (i = 0; i <= 4; ++i){

printf("\nElement %d is %d", i, grades[i] );

}

return 0;

}

### pgm 8.2

Using pointers for array access

#include <stdio.h>

int main()

{

int *gPtr;

int i;

int grades[] = {98, 87, 92, 79, 85};

for (i = 0; i <= 4; ++i){

printf("\nElement %d is %d", i, *(gPtr + i) );

}

return 0;

}

declare a pointer to an int

store the starting array address

(gPtr + 1) = &grades[1]

(gPtr + 2) = &grades[2]

(gPtr + 3) = &grades[3]

### More Pointer Math and Array Equivalency

• Are the parentheses necessary in the expression *(gPtr + 3)?

• Yes. Note the difference between: *(gPtr + 3) and *gPtr+3

• BIG difference. The parentheses are required

• Finally, the expression grades[i] can always be replaced with *(grades + i)

### Pointer Constants

Assume the following declarations have been made:

int a[10];

int *pa;

Important difference between an array name and a pointer variable:

• A pointer is a variable so it’s legal to use

• pa = a;

• pa++;

• An array name is a constant, not a variable. ILLEGAL usage

• a = pa; //Incompatible types int* and int[5]

• a++;//Not allowed

• pa = &a; //Both types must be same

### Pointer Constants

• When arrays are created, an internal “pointer constant” is automatically created

• This pointer constant stores the starting address of the array, i.e., the first element

• What happens when an array is declared?

• The array name becomes the name of a pointer constant

• The first array element is stored at the pointer’s address

• Storage is created for the appropriate number of the indicated variable type

### pgm 8.3

A ‘constant’ pointer named grades is automatically generated

#include <stdio.h>

int main()

{

int i;

int grades[] = {98, 87, 92, 79, 85};

for (i = 0; i <= 4; ++i)

printf("\nElement %d is %d", i, *(grades + i) );

return 0;

}

Pointer notation used although no explicit pointer declared!

B Smith:

B Smith:

3/11/2005 9:58 AM: Stopped here

### Pointer Arithmetic – Marching Through Arrays

• You can use pointers to index through arrays by pointing to each element in turn

• Given that p points to wilma[i], p + k points to wilma[i + k]

int wilma[4], i,*p, x;

wilma[4]={21, 9, 19, 6};

p = &wilma[0];

x = *p;

x = *(p+1);

p = p + 1;

p++;

address of wilma[0] assigned to p

wilma[0] is assigned to x

wilma[1] is assigned to x

&wilma[1] is assigned to p

p now points to wilma[2]

### Marching Through Arrays – an example

• *p++ can be used to walk through the array pointed to by p

• Given int wilma[4], i,*p, x;

• The same output is achieved by both of the following

p = wilma;

for (i = 0; i < 4; i++)

printf(“%d\n”, *p++);

for (i = 0; i < 4; i++)

printf(“%d\n”, wilma[i]);

store address of nums[0] in nPtr

### pgm8.5 Array Marching – Stop Based on Address

#include <stdio.h>

int main()

{

int nums[5] = {16, 54, 7, 43, -5};

int total = 0, *nPtr;

nPtr = nums;

while (nPtr <= nums + 4)

total += *nPtr++;

printf("The total of the array elements is %d", total);

return 0;

}

### Functions, Pointers and Using Array Addresses

• The array address is the only actual item passed

• What constitutes an array’s address?

• The following examples study the passing of arrays and pointers

### pgm 8.6a findMax routine

int findMax(int vals[], int numEls)

{

int i, max = vals[0];

for (i = 1; i < numEls; ++i)

if (max < vals[i])

max = vals[i];

return(max);

}

### pgm 8.6c findMax routine-changes

int vals[]

int findMax(int *vals, int numEls)

{

int i, max = *vals;

for (i = 1; i < numEls; ++i)

if (max < *(vals + i) )

max = *(vals + i);

return(max);

}

max = &vals[0]

max = vals[i]

### Revision

• Array Names as Pointers (§8.1)

• an array name is a pointer constant

• if val is the array, val and &val[0] can be used interchangeably

• Pointer Arithmetic (§8.2)

• a[i] can be replaced with *(a + i).

• Passing and Using Array Addresses (§8.3)

• if an array is to be passed to a function, f1(), both declarations are appropriate:

• f1( float a[] ) {...}

• f1( float *a ){...}

### Preparation

• Next Lecture:

• Ch 9

• Character Strings

• Pointers and Library Functions

• String Definitions and Pointer Arrays

• Formatting Strings