Transcript POINTERS - Universiti Malaysia Perlis

EKT120: Computer Programming
Week 11
Pointers
1
EKT 120:Computer 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
EKT 120:Computer 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
Pointer Variable Definitions and Initialization
• Pointer variables
• Contain memory addresses as their values
• Normal variables contain a specific value (direct
reference)
iNum
7
• Pointer contains an address of a variable that has a
specific value (indirect reference)
• Indirection – referencing a pointer value
piNum
iNum
7
EKT 120:Computer Programming
EKT 120:Computer 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
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; or int *piNum = 0;
EKT 120:Computer Programming
Pointer Operators
• Symbol & is called address operator
• Returns address of operand
int iNum = 7;
int *piNum;
piNum = &iNum;
/* piNum gets address of iNum */
piNum “points to” iNum
piNum
iNum
7
piNum
500000
600000
iNum
600000
Address of
iNum is value
of piNum
7
EKT 120:Computer 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
EKT 120:Computer Programming
Sample program
#include <stdio.h>
int main()
{
int iNum;
int *piNum;
int iNum1=5;
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
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;
EKT 120:Computer 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
Enter character : f
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);
}
10
Do you want to continue?y
Enter character : I
Do you want to continue?y
Enter character : k
Do you want to continue?n
Number of vowel : 1
Number of consonant : 2
void fnFindCountVC(char cCh1, int *piVowel, int *piConsonant)
{
switch(cCh1)
{ case 'A':
Functions that “return”
case 'a':
more than one value i.e.
case 'E':
arguments are passed by
case 'e':
reference
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);
}
EKT 120:Computer 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);
void fnInitializeArray (int aiX[ ], int iSizeX)
{
int iCounter;
for (iCounter = 0; iCounter < iSizeX; iCounter++)
aiX[iCounter] = 0;
}
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;
}
EKT 120:Computer 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
EKT 120:Computer 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
EKT 120:Computer 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
location
3000
3004
aiV[0]
pointer variable piVPtr
aiV[1]
3008
aiV[2]
3012
aiV[3]
3016
aiV[4]
EKT 120:Computer Programming
Pointer Expressions and Pointer Arithmetic
• Subtracting pointers
• Returns number of elements from one to the other. If
piVPtr2
piVPtr
= &aiV[ 2 ];
= &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
EKT 120:Computer 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
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] : 1245020
Address of piVPtr + 2: 1245028
Address of piVPtr + 4: 1245036
Contents of temp : 2
Contents of piP : 2147323904 piQ : 2147323904
EKT 120:Computer 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
EKT 120:Computer 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)
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
Example
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]
aiB[1]
aiB[2]
aiB[3]
aiB[4]
aiB[5]
aiB[6]
aiB[7]
aiB[8]
aiB[9]
=
=
=
=
=
=
=
=
=
=
10
20
30
40
50
0
0
0
0
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;
}
EKT 120:Computer 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
EKT 120:Computer Programming
Arrays of Pointers
acSuit[0]
’H’
’e’
’a’
’r’
’t’
’s’
’\0’
acSuit[1]
’D’
’i’
’a’
’m’
’o’
’n’
’d’
acSuit[2]
’C’
’l’
’u’
’b’
’s’
’\0’
acSuit[3]
’S’
’p’
’a’
’d’
’e’
’s’
’\0’
• acSuit array has a fixed size, but strings can be of any size
’s’
’\0’
EKT 120:Computer Programming
Example
#include <stdio.h>
#define N 5
int main()
{
char *acStudentName[N]; int iIndex;
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
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;
}
EKT120: Computer Programming
End Week 11
Q & A!
UniMAP Sem II – 12/13
24