EKT120 COMPUTER PROGRAMMING

EKT120COMPUTER PROGRAMMING Pointers Dr. NikAdilahHanin Bt. Zahri adilahhanin@unimap.edu.my

Outline • Introduction • Pointer Variable Definitions and Initialization • Pointer Operators • Calling Functions by Reference • Using the constQualifier with Pointers • Pointer Expressions and Pointer Arithmetic • Relationship between Pointers and Arrays • Arrays of Pointers

Introduction • Pointer is the address (i.e. a specific memory location) of an object. • It can refer to different objects at different times. • Pointers are used in C programs for a variety of purposes: • To return more than one value from a function(using pass by reference) • To create and process strings • To manipulate the contents of arrays and structures • To construct data structures whose size can grow or shrink dynamically

iNum piNum iNum 7 7 Pointer Variable Definitions and Initialization Pointer variables • Contain memory addresses as their values • Normal variables contain a specific value (direct reference) • Pointer contains an address of a variable that has a specific value (indirect reference) • Indirection – referencing a pointer value

Pointer Variable Definitions and Initialization Pointer definitions • * used with pointer variables int *piNum; • Defines a pointer to an int(pointer of type int *) • Multiple pointers require using a * before each variable definition int *piNum1, *piNum2; • Can define pointers to any data type • Initialize pointers to 0, NULL, or an address • 0 or NULL– points to nothing (NULL preferred) • int *piNum = NULL; orint *piNum = 0;

piNum iNum iNum 7 piNum Address of iNum is value of piNum 500000 600000 600000 7 Pointer Operators • Symbol & is called address operator • Returns address of operand intiNum = 7; int *piNum; piNum = &iNum; /* piNum gets address of iNum */ piNum “points to” iNum

Pointer Operators • Symbol * is called indirection/dereferencing operator • Returns a synonym/alias of what its operand points to e.g. *piNum returns iNum (because piNum points to iNum) • * can also be used for assignment • Returns alias to an object e.g. *piNum = 10; /* changes iNum to 10 */ • Dereferenced pointer (operand of *) must be an lvalue (no constants) • * and & are inverses • They cancel each other out

Sample Program #include <stdio.h> int main() { int iNum; int *piNum; int iNum1=5; iNum= 7; printf("number = %d\n", iNum); piNum= &iNum; printf(“piNum points to iNum whereby the value is = %d\n",*piNum); printf("Address of piNum : %d Contents of piNum : %d\n", &piNum, piNum); printf("Address of iNum : %d\n\n", &iNum); *piNum = 15; printf("Dereferencing pointer, *piNum = %d\n", *piNum); iNum= iNum + iNum1; printf(“iNum = %d\n”, iNum); printf("*piNum = %d\n", *piNum); printf("*piNum + iNum1 = %d\n", *piNum + iNum1); return 0; }

Sample Program #include <stdio.h> int main() { int iNum; int *piNum; int iNum1=5; iNum= 7; printf("number = %d\n", iNum); piNum= &iNum; printf(“piNum points to iNum whereby the value is = %d\n",*piNum); printf("Address of piNum : %d Contents of piNum : %d\n", &piNum, piNum); printf("Address of iNum : %d\n\n", &iNum); *piNum = 15; printf("Dereferencing pointer, *piNum = %d\n", *piNum); iNum= iNum + iNum1; printf(“iNum = %d\n”, iNum); printf("*piNum = %d\n", *piNum); printf("*piNum + iNum1 = %d\n", *piNum + iNum1); return 0; } number = 7 piNum points to iNum whereby the value is = 7 Address of piNum : 1245060 Contents of piNum : 1245064 Address of iNum : 1245064 Dereferencing pointer, *piNum = 15 iNum = 20 *piNum = 20 *piNum + iNum1 = 25

Calling Functions by Reference • Call by reference with pointer arguments • Passes address of argument using & operator • Allows you to change actual location in memory • Arrays are not passed with ‘&’ because the array name is already a pointer • * operator • Used as alias or nickname for variable inside of function void fnFun1 (int*piNumber) { *piNumber = 2 * (*piNumber); } • *piNumberused as nickname for the variable passed

Pass by Reference (Example) #include <stdio.h> void fnFun1(int, int*, int*); //function prototype int main(void) { intiA=5,iB=10,iC=15; printf("Before fun 1\n”); printf(“iA = %d iB = %d iC = %d”,iA,iB,iC); fnFun1(iA, &iB, &iC); //function call printf(“\n\nAfter fun 1\n”); printf(“iA = %d iB = %d iC = %d”,iA,iB,iC); return 0; } void fnFun1(intiAA,int*iBB, int *iCC)//function definition { ++iAA; --*iBB; ++*iCC; printf("\n\nInside fnFun1\n”); printf(“iAA = %d iBB = %d iCC= %d”,iAA,*iBB,*iCC); }

Pass by Reference (Example) #include <stdio.h> void fnFun1(int, int*, int*); //function prototype int main(void) { intiA=5,iB=10,iC=15; printf("Before fun 1\n”); printf(“iA = %d iB = %d iC = %d”,iA,iB,iC); fnFun1(iA, &iB, &iC); //function call printf(“\n\nAfter fun 1\n”); printf(“iA = %d iB = %d iC = %d”,iA,iB,iC); return 0; } void fnFun1(intiAA,int*iBB, int *iCC)//function definition { ++iAA; --*iBB; ++*iCC; printf("\n\nInside fnFun1\n”); printf(“iAA = %d iBB = %d iCC= %d”,iAA,*iBB,*iCC); } Functions that “return” more than one value i.e. arguments are passed by reference

Pass by Reference (Example) #include <stdio.h> void fnFun1(int, int*, int*); //function prototype int main(void) { intiA=5,iB=10,iC=15; printf("Before fun 1\n”); printf(“iA = %d iB = %d iC = %d”,iA,iB,iC); fnFun1(iA, &iB, &iC); //function call printf(“\n\nAfter fun 1\n”); printf(“iA = %d iB = %d iC = %d”,iA,iB,iC); return 0; } void fnFun1(intiAA,int*iBB, int *iCC)//function definition { ++iAA; --*iBB; ++*iCC; printf("\n\nInside fnFun1\n”); printf(“iAA = %d iBB = %d iCC= %d”,iAA,*iBB,*iCC); } OUTPUT Output Before fnFun1 iA = 5 iB = 10 iC= 15 Inside fnFun1 iAA = 6 iBB = 9 iCC = 16 After fnFun1 iA = 5 iB = 9 iC = 16

Pass by Reference : Array (Example) void fnMultiplyArray(intaiX[ ], intiSizeX) { intiCounter; for (iCounter= 0; iCounter< iSizeX; iCounter++) aiX[iCounter] = aiX[iCounter] * 10; } intfnIndexLargestElement(intaiX[],intSizeX) { intiCounter,iMaxIndex = 0; for(iCounter=0; iCounter<iSizeX; iCounter++) if(aiX[iMaxIndex] < aiX[iCounter] ) iMaxIndex = iCounter; return (iMaxIndex); } void fnPrintArray(intaiX[], intiSizeX) { intiCounter; for (iCounter = 0; iCounter < iSizeX; iCounter++) printf(“aiX[%d] = %d\n”,iCounter, aiX[iCounter]); } #include <stdio.h> intiArraySize = 5; intfnSumArray (intaiX[], intiSizeX); void fnPrintArray(intaiX[], intiSizeX); void fnPrintArray(inaiX[], intiSizeX); int main() { intaiListA [iArraySize] = {22, 55, 33, 11, 44}; intmaxIndexNo=0; fnPrintArray (aiListA, iArraySize); fnMultiplyArray (aiListA, iArraySize); fnPrintArray (aiListA, iArraySize); maxIndexNo=fnIndexLargestElement(intaiX[],intSizeX); printf(“\nLargest value is aiListA[%d] = %d \n”,maxIndexNo, aiListA[maxIndexNo]); return 0; }

Pass by Reference : Array (Example) void fnMultiplyArray(intaiX[ ], intiSizeX) { intiCounter; for (iCounter= 0; iCounter< iSizeX; iCounter++) aiX[iCounter] = aiX[iCounter] * 10; } intfnIndexLargestElement(intaiX[],intSizeX) { intiCounter,iMaxIndex = 0; for(iCounter=0; iCounter<iSizeX; iCounter++) if(aiX[iMaxIndex] < aiX[iCounter] ) iMaxIndex = iCounter; return (iMaxIndex); } void fnPrintArray(intaiX[], intiSizeX) { intiCounter; for (iCounter = 0; iCounter < iSizeX; iCounter++) printf(“aiX[%d] = %d\n”,iCounter, aiX[iCounter]); } #include <stdio.h> intiArraySize = 5; intfnSumArray (intaiX[], intiSizeX); void fnPrintArray(intaiX[], intiSizeX); void fnPrintArray(inaiX[], intiSizeX); int main() { intaiListA [iArraySize] = {22, 55, 33, 11, 44}; intmaxIndexNo=0; fnPrintArray (aiListA, iArraySize); fnMultiplyArray (aiListA, iArraySize); fnPrintArray (aiListA, iArraySize); maxIndexNo=fnIndexLargestElement(intaiX[],intSizeX); printf(“\nLargest value is aiListA[%d] = %d \n”,maxIndexNo, aiListA[maxIndexNo]); return 0; } • aiX[0] = 22 • aiX[1] = 55 • aiX[2] = 33 • aiX[3] = 11 • aiX[4] = 44 • aiX[0] = 220 • aiX[1] = 550 • aiX[2] = 330 • aiX[3] = 110 • aiX[4] = 440 • Largest value is aiX[1] = 550

Using the const Qualifier with Pointers • const qualifier • Variable cannot be changed • Use const if function does not need to change a variable • Attempting to change a const variable produces an error • const pointers • Point to a constant memory location • Must be initialized when defined • int *const piMyPtr = &iX; • Type int *const– constant pointer to an int • const int *piMyPtr = &iX; • Regular pointer to a const int • const int *const piPtr = &iX; • const pointer to a const int • iX can be changed, but not *piPtr

Pointer Expressions and Pointer Arithmetic • Arithmetic operations can be performed on pointers • Increment/decrement pointer (++ or --) • Add an integer to a pointer( + or += , - or -=) • Pointers may be subtracted from each other • Operations meaningless unless performed on an array

aiV[0] aiV[1] aiV[2] aiV[4] aiV[3] Pointer Expressions and Pointer Arithmetic • 5 element int array on machine with 4 byte ints • piVPtr points to first element aiV[0] • at location 3000 (piVPtr = 3000) • piVPtr += 2; sets piVPtr to 3008 • piVPtr points to aiV[2] (incremented by 2), but the machine has 4 byte ints, so it points to address 3008 location 3000 3004 3008 3012 3016 pointer variable piVPtr

Pointer Expressions and Pointer Arithmetic • Subtracting pointers • Returns number of elements from one to the other. If piVPtr2 = &aiV[2]; piVPtr = &aiV[0]; • piVPtr2 - piVPtrwould produce 2 • Pointer comparison ( <, == , > ) • See which pointer points to the higher numbered array element • Also, see if a pointer points to 0

Pointer Expressions and Pointer Arithmetic • Pointers of the same type can be assigned to each other • If not the same type, a cast operator must be used • Exception: pointer to void (type void *) • Generic pointer, represents any type • No casting needed to convert a pointer to void pointer • void pointers cannot be dereferenced

Example of Pointer Operation #include <stdio.h> int main() { int *piVPtr, *piVPtr2; intaiV[5] = {10,20,30,40,50}, iTemp; piVPtr= aiV; printf("Address of piVPtr : %d \nContents of piVPtr : %d\n", &piVPtr, piVPtr); printf("Address of aiV[0] : %d\n", &aiV); piVPtr +=2; printf("Address of piVPtr + 2: %d\n", piVPtr); piVPtr +=2; printf("Address of piVPtr + 4: %d\n", piVPtr); piVPtr2=&aiV[2]; piVPtr=&aiV[0]; iTemp=piVPtr2-piVPtr; printf("Contents of iTemp : %d\n", iTemp); return 0; }

Example of Pointer Operation #include <stdio.h> int main() { int *piVPtr, *piVPtr2; intaiV[5] = {10,20,30,40,50}, iTemp; piVPtr= aiV; printf("Address of piVPtr : %d \nContents of piVPtr : %d\n", &piVPtr, piVPtr); printf("Address of aiV[0] : %d\n", &aiV); piVPtr +=2; printf("Address of piVPtr + 2: %d\n", piVPtr); piVPtr +=2; printf("Address of piVPtr + 4: %d\n", piVPtr); piVPtr2=&aiV[2]; piVPtr=&aiV[0]; iTemp=piVPtr2-piVPtr; printf("Contents of iTemp : %d\n", iTemp); return 0; } Address of piVPtr : 1245064 Contents of piVPtr : 1245020 Address of aiV[0] : 1245020 Address of piVPtr + 2: 1245028 Address of piVPtr + 4: 1245036 Contents of iTemp : 2

The Relationship between Pointers and Arrays • Arrays and pointers are closely related • Array name like a constant pointer • Pointers can do array subscripting operations • Define an array aiB[5]and a pointer piBPtr • To set them equal to one another use: piBPtr = aiB; The array name (aiB) is actually the address of first element of the array aiB[5] piBPtr = &aiB[0]; Explicitly assigns piBPtr to the address of first element of aiB

The Relationship between Pointers and Arrays • Element aiB[3] • Can be accessed by *(piBPtr + 3) • Where * is the offset. Called pointer/offset notation • Can be accessed by piBPtr[3] • Called pointer/subscript notation • piBPtr[3] same as aiB[3] • Can be accessed by performing pointer arithmetic on the array itself *(aiB + 3)

Example 1 #include <stdio.h> int main() { int *piBPtr ;intiIndex; intaiB[10]={10,20,30,40,50}; piBPtr = aiB; printf("Address of piBPtr : %d \nContents of piBPtr : %d\n", &piBPtr, piBPtr); printf("Address of aiB : %d \nContents of aiB[0]:%d %d %d\n", &aiB, aiB[0], *piBPtr, *aiB); printf(“piBPtr points to aiB[0] = %d\n", *piBPtr); printf("\nI am accessing element aiB[3]!!\nLet see how many ways I can do it\n"); printf(“aiB[3] = %d\n", aiB[3]); printf("*(piBPtr + 3) = %d\n", *(piBPtr + 3)); printf("*(aiB + 3) = %d\n", *(aiB + 3)); printf(“piBPtr[3] = %d\n\n", piBPtr[3]); for(iIndex=0;iIndex<10;iIndex++) printf(“aiB[%d] = %d\n", iIndex, *(piBPtr+iIndex)); return 0; }

Example 1 Address of piBPtr : 1245064 Contents of piBPtr : 1245016 Address of aiB : 1245016 Contents of aiB[0]:10 10 10 piBPtr points to aiB[0] = 10 I am accessing element aiB[3]!! Let see how many ways I can do it aiB[3] = 40 *(piBPtr + 3) = 40 *(aiB + 3) = 40 piBPtr[3] = 40 aiB[0] = 10 aiB[1] = 20 aiB[2] = 30 aiB[3] = 40 aiB[4] = 50 aiB[5] = 0 aiB[6] = 0 aiB[7] = 0 aiB[8] = 0 aiB[9] = 0 #include <stdio.h> int main() { int *piBPtr ;intiIndex; intaiB[10]={10,20,30,40,50}; piBPtr = aiB; printf("Address of piBPtr : %d \nContents of piBPtr : %d\n", &piBPtr, piBPtr); printf("Address of aiB : %d \nContents of aiB[0]:%d %d %d\n", &aiB, aiB[0], *piBPtr, *aiB); printf(“piBPtr points to aiB[0] = %d\n", *piBPtr); printf("\nI am accessing element aiB[3]!!\nLet see how many ways I can do it\n"); printf(“aiB[3] = %d\n", aiB[3]); printf("*(piBPtr + 3) = %d\n", *(piBPtr + 3)); printf("*(aiB + 3) = %d\n", *(aiB + 3)); printf(“piBPtr[3] = %d\n\n", piBPtr[3]); for(iIndex=0;iIndex<10;iIndex++) printf(“aiB[%d] = %d\n", iIndex, *(piBPtr+iIndex)); return 0; }

Arrays of Pointers • Arrays can contain pointers • For example: an array of strings char *acSuit[4] = {“Hearts”,“Diamonds”,“Clubs”,“Spades”}; • Strings are pointers to the first character • char *– each element of acSuit is a pointer to a char • The strings are not actually stored in the array acSuit, only pointers to the strings are stored

’\0’ ’\0’ ’\0’ ’\0’ ’d’ ’s’ ’o’ ’a’ ’n’ ’u’ ’d’ ’b’ ’m’ ’s’ ’e’ ’r’ ’D’ ’i’ ’a’ ’e’ ’t’ ’C’ ’H’ ’l’ ’s’ ’S’ ’p’ ’s’ ’a’ acSuit[0] acSuit[1] acSuit[2] acSuit[3] Arrays of Pointers • acSuit array has a fixed size, but strings can be of any size

Example 2 #include <stdio.h> #define N 5 int main() { char *acStudentName[N]; intiIndex; for(iIndex=0;iIndex<5;iIndex++) { printf("Enter student[%d] name : ", iIndex); scanf("%s", acStudentName + iIndex); printf("You just entered :\n%s\n", acStudentName + iIndex); } return 0; }

Example 2 #include <stdio.h> #define N 5 int main() { char *acStudentName[N]; intiIndex; for(iIndex=0;iIndex<5;iIndex++) { printf("Enter student[%d] name : ", iIndex); scanf("%s", acStudentName + iIndex); printf("You just entered :\n%s\n", acStudentName + iIndex); } return 0; } Enter student[0] name : ali You just entered : ali Enter student[1] name : abu You just entered : abu Enter student[2] name : cheah You just entered : cheah Enter student[3] name : dali You just entered : dali Enter student[4] name : gheeta You just entered : gheeta

EKT120 COMPUTER PROGRAMMING