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.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

PowerPoint Slideshow about ' Math 130 Introduction to Computing Arrays and Pointers Lecture # 16' - miette

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

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.

• 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

• 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:

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

• 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];

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;

}

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

• 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)

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

• 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

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:

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]

• *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]);

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;

}

• 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

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);

}

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]

• 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 ){...}

• Next Lecture:

• Ch 9

• Character Strings

• Pointers and Library Functions

• String Definitions and Pointer Arrays

• Formatting Strings