pgt 106 c programming pointers. pgt 106 c programming outline introduction pointer variable...
DESCRIPTION
PGT 106 C Programming 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 dynamicallyTRANSCRIPT
PGT 106 C Programming
POINTERS
PGT 106 C Programming
Outline Introduction Pointer Variable Definitions and
Initialization Pointer Operators Calling Functions by Reference Using the const Qualifier with Pointers Pointer Expressions and Pointer
Arithmetic Relationship between Pointers and Arrays Arrays of Pointers
PGT 106 C Programming
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
PGT 106 C Programming
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
iNum
7
iNum7
piNum
PGT 106 C Programming
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 definitionint *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; or int *piNum = 0;
PGT 106 C Programming
Pointer Operators Symbol & is called address operator
Returns address of operandint iNum = 7;int *piNum; piNum = &iNum; /* piNum gets address of iNum */piNum “points to” iNum
piNum
iNum7
piNum
500000 600000
iNum
600000 7
Address of iNum is value of piNum
PGT 106 C Programming
Pointer Operators Symbol * is called
indirection/dereferencing operator Returns a synonym/alias of what its operand points to
*piNum returns iNum (because piNum points to iNum) * can also be used for assignment
Returns alias to an object*piNum = 10; /* changes iNum to 10 */ show pictures!!
Dereferenced pointer (operand of *) must be an lvalue (no constants)
* and & are inverses They cancel each other out
PGT 106 C Programming
#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 programnumber = 7piNum points to iNum whereby the value is = 7Address of piNum : 1245060 Contents of piNum : 1245064Address of iNum : 1245064
Dereferencing pointer, *piNum = 15iNum = 20*piNum = 20*piNum + iNum1 = 25
PGT 106 C Programming
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);
} *piNumber used as nickname for the variable
passed
10
Remember..last time#include <stdio.h>#include <string.h>char fnRead();void fnFindCountVC(char, int*, int*);void fnPrint(int,int);
int main(){ char cCh, cChoice; int iCountV=0, iCountC=0; do { cCh = fnRead(); fnFindCountVC(cCh, &iCountV,
&iCountC); printf("Do you want to continue? "); scanf("%c", &cChoice); getchar(); }while((cChoice == 'y') ||(cChoice =='Y')); fnPrint(iCountV,iCountC); return 0;}
char fnRead(){ char cCh1; printf("Enter character : "); scanf("%c", &cCh1); getchar(); return(cCh1);}
void fnFindCountVC(char cCh1, int *piVowel, int *piConsonant)
{ switch(cCh1) { case 'A': case 'a': case 'E': case 'e': case 'I': case 'i': case 'O': case 'o': case 'U': case 'u': *piVowel = *piVowel +1;break; default: *piConsonant = *piConsonant + 1; }}void fnPrint(int iVowel, int iConsonant){
printf("Number of vowel : %d\n", iVowel); printf("Number of consonant : %d\n", iConsonant);}
Enter character : fDo you want to continue?yEnter character : IDo you want to continue?yEnter character : kDo you want to continue?nNumber of vowel : 1Number of consonant : 2
Functions that “return” more than one value i.e. arguments are passed by reference
PGT 106 C Programming
Remember…last time#include <stdio.h>
const int iArraySize = 10;void fnInitializeArray (int aiX[], int iSizeX);void fnFillArray (int aiX[], int iSizeX);void fnPrintArray (const int aiX[], int iSizeX);int fnSumArray (const int aiX[], int iSizeX);int fnIndexLargestElement (const int aiX[], int iSizeX);void fnCopyArray (const int aiX[], int aiY[], int
iLength);
int main(){
int aiListA [iArraySize] = {0};int aiListB [iArraySize];
fnPrintArray (aiListA, iArraySize);fnInitializeArray (aiListB, iArraySize);fnPrintArray (aiListB, iArraySize);fnFillArray (aiListA, iArraySize);fnPrintArray (aiListA, iArraySize);fnSumArray (aiListA, iArraySize);fnCopyArray (aiListA, aiListB, iArraySize);fnPrintArray (aiListB, iArraySize);return 0;
}
void fnInitializeArray (int aiX[ ], int iSizeX){int iCounter;
for (iCounter = 0; iCounter < iSizeX; iCounter++)
aiX[iCounter] = 0;}
PGT 106 C Programming
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
PGT 106 C Programming
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
PGT 106 C Programming
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
pointer variable piVPtr
aiV[0] aiV[1] aiV[2] aiV[4]aiV[3]
3004 3008 3012 3016location3000
PGT 106 C Programming
Pointer Expressions and Pointer Arithmetic Subtracting pointers
Returns number of elements from one to the other. IfpiVPtr2 = &aiV[ 2 ];piVPtr = &aiV[ 0 ];
piVPtr2 - piVPtr would produce 2
Pointer comparison ( <, == , > ) See which pointer points to the higher
numbered array element Also, see if a pointer points to 0
PGT 106 C Programming
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
UniMAP SemII-09/10 PGT 106 C Programming
Example of Pointer Operation
#include <stdio.h>int main(){int *piVPtr; int *piVPtr2;int aiV[5] = {10,20,30,40,50}; int iTemp;int *piP, *piQ;
piVPtr= aiV;printf("Address of piVPtr : %d Contents 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);
piP=piQ;printf("Contents of piP : %d piQ : %d\n", piP,
piQ);return 0;}
Address of piVPtr : 1245064 Contents of piVPtr : 1245020
Address of aiV[0] : 1245020Address of piVPtr + 2: 1245028Address of piVPtr + 4: 1245036Contents of temp : 2Contents of piP : 2147323904 piQ : 2147323904
PGT 106 C Programming
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
PGT 106 C Programming
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)
PGT 106 C Programming
Example
Address of piBPtr : 1245064 Contents of piBPtr : 1245016Address of aiB : 1245016 Contents of aiB[0]:10 10 10piBPtr points to aiB[0] = 10
I am accessing element aiB[3]!!Let see how many ways I can do itaiB[3] = 40*(piBPtr + 3) = 40*(aiB + 3) = 40piBPtr[3] = 40
aiB[0] = 10aiB[1] = 20aiB[2] = 30aiB[3] = 40aiB[4] = 50aiB[5] = 0aiB[6] = 0aiB[7] = 0aiB[8] = 0aiB[9] = 0
#include <stdio.h>int main(){ int *piBPtr ;int iIndex; int aiB[10]={10,20,30,40,50}; piBPtr = aiB; printf("Address of piBPtr : %d Contents of piBPtr : %d\n", &piBPtr, piBPtr); printf("Address of aiB : %d Contents 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;}
PGT 106 C Programming
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
PGT 106 C Programming
Arrays of Pointers
acSuit array has a fixed size, but strings can be of any size
acSuit[3]
acSuit[2]
acSuit[1]
acSuit[0] ’H’ ’e’ ’a’ ’r’ ’t’ ’s’ ’\0’
’D’ ’i’ ’a’ ’m’ ’o’ ’n’ ’d’ ’s’ ’\0’
’C’ ’l’ ’u’ ’b’ ’s’ ’\0’
’S’ ’p’ ’a’ ’d’ ’e’ ’s’ ’\0’
PGT 106 C Programming
Example#include <stdio.h>#define N 5int main(){ char *acStudentName[N]; int iIndex;
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 : aliYou just entered :aliEnter student[1] name : abuYou just entered :abuEnter student[2] name :
cheahYou just entered :cheahEnter student[3] name : daliYou just entered :daliEnter student[4] name :
gheetaYou just entered :gheeta