Chapter 8 Arrays, Strings and Pointers 8b: Pointers

Goals: Pointers & pointer operators Functions: Reference Parameter Pointers & Arrays Arrays of strings

Introduction - Variable Variable is a space in memory that is used to hold a value Each variable has a name, content, and address Variable name is a logical reference Address is a physical reference Variable name (logical reference) Address (physical reference)

Introduction - Variable Accessing content (value) & address int main() { int n = 33; printf("n = %d\n", n); //print the value printf(“&n = %d\n", &n); //print the address return 0; }

Introduction - Variable A char uses 1 byte int main() { char achar[100] = "\nABCDEFGxyz123"; printf("%s\n", achar); printf("%d\n", &achar[0]); printf("%d\n", &achar[1]); return 0; } Print the address Output: ABCDEFGxyz123 2686636 2686637

Introduction - Variable An int uses 4 bytes The address of an int variable is the first byte int main() { int aint[5] = {0, 1, 2, 3, 4}; printf("%d\n", &aint[0]); printf("%d\n", &aint[1]); return 0; } Print the address Output: 2686716 2686720

Introduction - Pointers Variable: A data variable contains a value (eg. Integer number, a real number or a character) . Pointers: Pointer is another type of variable that contains the address of other variable. It also known as address variable.

type_name *pointer_name; Name of the pointer variable Introduction - Pointers Pointer Declaration: Example: type_name *pointer_name; Pointer’s base type - determines what type of data the pointer will be pointing to Name of the pointer variable - determines what type of data the pointer will be pointing to int* ip; float* fp; ip to be a pointer to an int (ip can be used to point to int values) fp can be used to point to float values

Introduction - Pointers Pointer Initialization:

Introduction - Pointers Using Pointer: Example: int a = -123; //a is a data variable int *p; //p is a pointer variable p = &a; //p then holds the address of variable a

Pointer Operators Two special operators: &: reference pointer (address operator) returns the memory address of its operand ptr = &total; *: dereference pointer (indirection operator) returns the value of the variable located at the address specified by its operand val = *ptr;

Pointer Operators Two special operators: Example: Pointer value, reference and dereference int main() { int a = -123; int* p = &a; //p holds the address of a printf("n = %d\n", a); printf("&n = %d\n", &a); printf("p = %d\n", p); //pointer value – address of a printf("&p = %d\n", &p);//reference – address of p printf("*p = %d\n", *p); //dereference – value of p return 0; }

Pointer Operators Two special operators: Example: p and q points to the same variable int a = -123; //a is a data variable int *p; //p is a pointer variable int *q; //q is a pointer variable p = &a; //p holds the address a q = p; //q = p =address of a

Pointer Operators Two special operators: Question: What will be the output? int main() { int a = 11; int b = 0; int* p1 = &a; int* p2 = &b; printf("%d %d\n", *p1, *p2); p2 = p1; a = 12; b = 1; return 0; }

Assigning Values through Pointers Assign a value to the location pointed to by the pointer Example Assigns value 101 to the location pointed to by p *p = 101; To increment (or decrement) the value at the location pointed to by a pointer: (*p)++; Note: * operator has lower precedence than ++ operator

Assigning Values through Pointers Example: int main() { int *p; int num; p = # *p = 100; //assign num the value 100 through pointer p printf("%d\n", num); (*p)++; //increment num through p (*p)--; //decrement num through p return 0; }

Pointer Arithmetic Pointer Arithmetic: You can add an integer offset to the pointer to point at another location Consider the following code: What will happen to the following code? p++; Current value of p = 2000 (address of n) After the p++: p = 2004, not 2,001. Reason? when p is incremented, it will point to the next int. Same for decrement.

Pointer Arithmetic Example: int main() { int n = 33; int *p; p = &n; //p hold the address of n; printf("%x\n", p); p++; //increment p, point to next int return 0; }

Pointer Arithmetic Add or subtract integers to or from pointers: p = p + 9; makes p point to the ninth element of p’s base type Rules: Add/Subtract MUST be perform between a pointer and integer Cannot add (or subtract) pointer and pointer. Cannot add or subtract float or double values to or from pointers

Recall: index starts at 0 Pointer & Array Array & pointer may be used interchangeably: Array name → constant pointer Pointer → array subscripting Consider this fragment: int b[5]; //integer array int *bPtr; //integer pointer bPtr = b; //bPtr points to 1st element of array b //equivalent to bPtr = &b[0]; Purpose Array Pointer Accessing an element → array as pointer → pointer as array b[3] = *(b+3) *(bPtr + 3) = bPtr[3] Address of an element &b[3] bPtr + 3 Integer offset Recall: index starts at 0

Pointer & Array Example: int main() { int number[] = {0, 1, 2, 3, 4}; int *ptr = number; //ptr points to number [0] printf("%d\n", * ptr); ptr ++; //ptr point to next int, number[1] return 0; }

Pointer to Character Array → String Strings are represented as arrays of char values. Exp: Strings stored inside char arrays: (always store ‘\0’ as null terminator) Strings stored as char pointer:

Pointer to Character Array → String Copying character pointer: Determine the output char *p = "Harry"; char *q = p; printf("%s %s\n", p, q); char string1[10]; char *string2 = "hello"; int i = 0; while(string1[i] != '\0' || string2[i] != '\0') { string1[i] = string2[i]; i++; } printf("%s %s\n", string1, string2 );

Pointer to Character Array → String Copying character pointer (function): copy s1 to s2: void copy(const char *s1, char *s2) { int i = 0; while(s1[i] != '\0' || s2[i] != '\0') s1[i] = s2[i]; i++; }

Value vs Reference Parameter Value Parameters: The parameter variables we have looked at so far are called value parameters. Value parameters are separate (new) variables from the ones in main()(or another calling function). Modification of value parameters does not affect the original value. Reference parameters: Reference parameter does not create a new variable, BUT refer to an existing variable Pass the memory address Any change in a reference parameter is actually a change in the variable to which it refers. Syntax: function header: void f2(int *i) //pointer function calling: f2(&val); //pass the variable address Value parameter: Function header: void f1(int i) Function calling: f1(val); Reference parameter: Function header: void f1(int *i) Funciton calling: f1(&val);

Pointer & Function Use pointer to point to the address of variable passed into the function → reference parameter

Reference Parameter Reference parameters are useful in two cases: Change values: change the value of an actual parameter variable in the call. Return multiple value – use combination of return and reference parameter Efficiency: Especially common for passing structs or class objects If no changes are made to the parameter, it should be declared const

Reference Parameter Example 1: Change actual parameter in function calling void f2(int *i); int main() { int val = 10; printf(“Old val in main(): %d \n”, val); f2(&val); printf(“New val in main(): %d \n”, val); return 0; } void f2(int *i) *i = 88; Old val in main(): 10 New val in main(): 88

Reference Parameter Example 2: “return” multiple result #include <math.h> void getSinCos(double dX, double *dSin, double *dCos) { *dSin = sin(dX); *dCos = cos(dX); } int main() double dSin = 0.0; double dCos = 0.0; //getSinCos() will return the sin and cos in dSin and dCos getSinCos(30.0, &dSin, &dCos); printf(“The sin is %lf\n”, dSin); printf(“The cosis %lf\n”, dCos); return 0; }

References Chapter 7: Text File, DCP 2073 C BASIC PROGRAMMING, NIK ISROZAIDI, FSKSM, UTM. (http://www.cheme.utm.my/cheme/images/Undergraduate/SUBJEC T/DCP2073/DCP2073%20NOTES7%20Files.pdf) C++ For Everyone, 2nd edition, Cay Horstmann.