 # UNIT 9: Pointers Data Variable and Pointer Variable Pass by Reference

## Presentation on theme: "UNIT 9: Pointers Data Variable and Pointer Variable Pass by Reference"— Presentation transcript:

UNIT 9: Pointers Data Variable and Pointer Variable Pass by Reference
Pointer Arithmetic Passing Array Using Pointers Dynamic Allocation

Address VS. Value Each memory cell could store some VALUE.
Each cell has an ADDRESS associated with it. Note: Don’t confuse the address referring to a memory location with the value stored in that location.

Pointer Just another C variable whose value is an address of another variable. “Points to” that other variable.

Declaring a pointer Syntax: Examples:
<data_type > *<pointer_name>; Examples: int *ptr; char *cp; float *fp; Note: <data_type > is the type of the data the pointer points to.

Declaring a pointer After declaring a pointer: int *ptr;
ptr doesn’t actually point to anything yet. (null pointer) We can either: make it point to something that already exists allocate room in memory for something new that it will point to

Declaring a pointer Declaring a pointer just allocates space to hold the pointer; it does not allocate something to be pointed to. If local variables in C are not initialized, they may contain anything.

Operators Associated with Pointers
Reference operator (&) Also known as the address operator Read as “address of” Dereference operator (*) Read as ”value pointed by”

Reference Operator (&)
The address that locates a variable within memory is what we call a reference to that variable. Example: int andy; int *ted; ted = &andy;

Reference Operator (&)
Example: andy = 25; fred = andy; ted = &andy;

Dereference Operator (*)
Using a pointer we can directly access the value stored in the variable which it points to. Example: beth = *ted; /* beth is equal to value pointed by ted */

Dereference Operator (*)
Differentiate: beth = ted; /* beth equal to ted ( 1776 ) */ beth = *ted; /* beth equal to value pointed by ted ( 25 ) */ Note: Reference and dereference operators have complementary (or opposite) meanings. A variable referenced with & can be dereferenced with *.

Pointers Examples: andy = 25; ted = &andy; After these expressions:

Pointers Data Variable int x=5; Pointer Variable x=5 &x x=5 address
int *p; p=&x; printf(“%p”, p); printf(“%d”, *p); the data inside address p x=5 &x=FF00 p=address (FF00) &x x=5 address data

Sample Program : Pointers
1 /* Filename: Pointers.c Program Description: Pointer example */ Predict the output: 2 3 4 5 6 7 8 9 10 11 12 #include<stdio.h> main() { int count, value; int *count_address; count = 100; count_address=&count; value= *count_address; printf(“\n %p”, count_address); printf(“\n %d”, value); getch(); } 13 14 15 16 17 18 19 20

Review: Parameter Passing
Two Ways: Pass by Value Pass by Reference

Review: Pass by Value int cubeByValue( int ); main() { int n = 5; printf(“Original value: %d”, n); n = cubeByValue( n ); printf(“\nNew value: %d”, n); getch(); ) int cubeByValue( int n ) { return n * n * n; }

Example 1: Pass by Reference
int cubeByReference( int * ); main() { int n = 5; printf(“Original value: %d”, n); n = cubeByReference( &n ); printf(“\nNew value: %d”, n); getch(); ) int cubeByReference( int *nPtr ) { *nPtr = *nPtr * *nPtr * *nPtr; return *nPtr; }

Example 2: Pass by Reference
void cubeByReference( int * ); main() { int n = 5; printf(“Original value: %d”, n); cubeByReference( &n ); printf(“\nNew value: %d”, n); getch(); } void cubeByReference( int *nPtr ) { *nPtr = *nPtr * *nPtr * *nPtr; }

Exercise: Create a function that would swap two numbers. The numbers must be pass as parameters of that function: Using pass by value Using pass by reference

Pointer Arithmetic Pointers only have limited set of operations:
A pointer could be incremented (++) and decremented (--) An integer may be added (+, +=) to a pointer An integer may be subtracted (-, -=) from a pointer One pointer may be subtracted from another

Pointer Arithmetic int v; vPtr can be initialized by:
vPtr = v; vPtr = &v; The diagram considers a machine (computer) with 4-byte integers. 5 9 8 7 6 v v v v v 3000 vPtr

Pointer Arithmetic Example: vPtr += 2; Result: 3000 + 2 * 4 = 3008 5 9
7 6 v v v v v 3000 vPtr 3008 vPtr

Pointer Arithmetic For arrays of other data types, vPtr would be incremented by twice the number of bytes that it takes to store an object of that data type. Example: char v; vPtr += 2; Result: * 1 = 3002 ‘5’ ‘9’ ‘8’ ‘7’ ‘6’ v v v v v 3000 vPtr 3002 vPtr

Pointer Arithmetic Same case of a 2-byte integer machine. Example:
int v; vPtr += 2; Result: * 2 = 3004 Most computers have 2-byte or 4-byte integers. Some newer ones uses 8-byte machines. Because of this, pointer arithmetic is machine-dependent. ‘5’ ‘9’ ‘8’ ‘7’ ‘6’ v v v v v 3000 vPtr 3004 vPtr

Pointer Arithmetic If these are conducted in sequence:
vPtr is incremented to 3016: vPtr += 4; vPtr is set back to address 3000: vPtr -= 4; To increment vPtr: ++vPtr; or vPtr++; To decrement vPtr: --vPtr; or vPtr--; 5 9 8 7 6 v v v v v 3000 vPtr

Pointer Arithmetic What would be the value of x? x = v2Ptr – vPtr;
Pointer arithmetic is meaningless unless performed on an array. 5 9 8 7 6 v v v v v 3000 vPtr 3008 v2Ptr

Pointer Arithmetic Pointers can be compared using equality and relational operators, but is meaningless unless pointers point to members of the same array. Pointer comparisons compare the addresses stored in the pointers.

Generic Pointers A pointer can be assigned to another pointer if both pointers are of the same type. *a = *b; Otherwise, a cast operator must be used to convert the pointer. *a = * (int *) b;

Generic Pointers Exception: pointer to void (i.e. void *)
Generic pointers can represent any pointer type. A cast operation is not required but we can cast any data variable as a pointer to void. A pointer to void cannot be dereferenced.

Example: Generic Pointers
main() { int i; char c; void *v; clrscr(); i = 6; c = 'a'; v = &i; printf(“v points to %d\n", *(int *) v); v= &c; printf(“v now points to %c\n", *(char *) v); getch(); }

Pointer Arithmetic VALID: INVALID: Adding 2 pointers.
Add an integer to a pointer. Subtract an integer from a pointer. Subtract 2 pointers (from the same array). Compare pointers (<, <=, ==, !=, >, >=). Compare pointer to NULL (indicates that pointer points to nothing). INVALID: Adding 2 pointers. Multiplying pointers. Dividing pointers. Subtracting a pointer from integer. Add or subtract type float or double to or from pointers.

Pointer Arithmetic Predict the output:
int x = { 1, 2, 3, 4, 5 }; printf(“\n %d”, *p1 ); int *p1; x = *p1 + p1; p1 = x; printf(“\n %d”, x ); p1++;

Arrays and Pointers Arrays and pointers are closely related
An array name is a constant pointer The name of the arrays points to the address/location of the first element of the array. Constant pointer means that it’s value (address/reference) could not be changed.

Arrays and Pointers Using ARRAY INDEXING: int v; v 5 9 8 7 6
v v v v v int v;

Arrays and Pointers Using POINTER MANIPULATION: int v; int *p = v;
Pointers can also be subscripted (indexed) exactly like arrays can. This is referred to as pointer/subscript notation. int v; int *p = v; 5 9 8 7 6 p p p p p 3000 p

Arrays and Pointers Using POINTER MANIPULATION: int v; int *p = v;
Using pointer arithmetic, the array could be traversed. 5 9 8 7 6 p p p p p 3000 p int v; int *p = v; p++; p += 3; *p--;

Passing Arrays using Pointers
Sample Program : Passing Array Using Pointer 1 /* Filename: ArrayPtr.c Program Description: Display the string character by character */ Predict the output: 2 3 4 5 6 7 8 9 10 11 12 #include<stdio.h> void Display(char *p); main() { char str = “hello”; Display( str ); getch(); } void Display( char *p ) while( *p ) putchar( *p ); p++; 13 14 15 16 17 18 19 20

Double Pointers A pointer whose value is the address of another pointer. Also called as a Pointers to pointers (i.e. pointers to int, pointers to char, etc.) Syntax: int **ptr; char **a;

Double Pointers Example: int **ipp; int i = 5, j = 6; k = 7;
int *ip1 = &i, *ip2 = &j; ipp = &ip1; 7 5 6 i j k 3000 … 4FF1 … … 581C 123D ipp 3000 ip1 4FF1 ip2 54EA POINTER VALUES: *ipp = 3000 **ipp = 5

Double Pointers Example: *ipp = ip2; 7 5 6 i j k 3000 … 4FF1 … … 581C
54EA POINTER VALUES: *ipp = 4FF1 **ipp = 6

Double Pointers Example: *ipp = &k; 581C ip1 123D 7 5 6 i j k
3000 … 4FF1 … … 581C 123D ipp 4FF1 ip2 54EA POINTER VALUES: *ipp = 581C **ipp = 7

Dynamic Memory Allocation
Allows to programmers to allocate (reserve) memory dynamically. Obtain more memory space at execution time. Common Library functions associated: malloc() free() sizeof()

Dynamic Memory Allocation
Sample Program : Dynamic Allocation /* Filename: Dynamic.c Program Description: Using malloc */ Output: 5 10 20 30 40 #include<stdio.h> main() { int *p1,x; int *p; p1=(int *) malloc(sizeof(int)); *p1= 5; printf(“\n%d”, *p1); p = (int *) malloc( sizeof( int )); p = (int *) malloc( sizeof ( int)); p = (int *) malloc( sizeof( int )); p = (int *) malloc( sizeof( int )); *p = 10; *p = 20; *p = 30; *p = 40; for(x=0; x<4; x++) printf(“\n%d”, *p ); free( p[x] ); getch(); }

Pointers EXERCISE (By pairs):
Make a function that accepts a pointer to a string and determine how many letter A’s are there in the string. Make a function that accepts an array of n integers and returns the average of these integers. Implement using pointers.

NOTES http://www.pcblab.net78.net/forum/
(PCBLab Forum > ComE Subjects > ComE 211)

Similar presentations