Math 130 introduction to computing arrays and pointers lecture 16
This presentation is the property of its rightful owner.
Sponsored Links
1 / 19

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


  • 39 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

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


Math 130 introduction to computing arrays and pointers lecture 16

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

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

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)


Pointer arithmetic

grades[0]

grades[1]

grades[2]

grades[3]

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

  • The address of grades[3] is the address of grades[0] plus 12


Using pointers to access array elements

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

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

pgm 8.2

Using pointers for array access

#include <stdio.h>

int main()

{

int *gPtr;

int i;

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

gPtr = &grades[0];

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

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

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 constants1

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

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!


Pointer arithmetic marching through arrays

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

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


Pgm8 5 array marching stop based on address

store address of nums[0] in nPtr

compare addresses

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

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

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

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

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

Preparation

  • Next Lecture:

    • Ch 9

      • Character Strings

      • Pointers and Library Functions

      • String Definitions and Pointer Arrays

      • Formatting Strings


  • Login