Scribd
Upload
18 views14 pages

Pointer C++

Uploaded by

Azan Mehdi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
18 views14 pages

Pointer C++

Uploaded by

Azan Mehdi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 14

++Pointer In C

Made By : Khalid Khan

1
++Pointers in C

Topics to cover:

• Overview of Pointers
• Pointer Declaration
• Pointer Assignment
• Pointer Arithmetic
• Relations Between Pointers and Arrays
• Pointers and Strings

2
Reference and Pointer
Variables
The object hello occupies
some computer memory.

The asterisk indicates that hello_ptr is a pointer


to a string. hello_ptr variable is assigned the
memory address of object hello which is
accessed with the “&” syntax.

The & here indicates that hello_ref is a reference to a


string. The hello_ref variable is assigned the memory
address of object hello automatically.

.Variable and object values are stored in particular locations in the computer’s memory •
.Reference and pointer variables store the memory location of other variables •
Pointers are found in C. References are a C++ variation that makes pointers easier and safer to •
.use
.More on this topic later in the tutorial •
Overview of Pointers

• A Pointer in C++ is variable whose value is a memory


address.
• With pointers many memory locations can be
referenced.
• Some data structures use pointers (e.g. linked list,
tree).
• The * and & operators
- & operator is the address operator
- * operator is the dereferencing operator. It is used in
pointers declaration

4
Pointer Declaration

• Pointers are declared as follows:


<type> * variable_name ;
e.g.
int * xPtr; // xPtr is a pointer to data of type integer

char * cPtr; //cPtr is a pointer to data of type character

void * yPtr; // yPtr is a generic pointer,


// represents any type

5
Pointer Assignment
• Assignment can be applied on pointers of the same type
• If not the same type, a cast operator must be used
• Exception: pointer to void does not need casting to convert a
pointer to void type
• void pointers cannot be dereferenced
• Example
int *xPtr, *yPtr; int x = 5;
…
xPtr = & x; // xPtr now points to address of x
yPtr = xPtr; // now yPtr and xPtr point to x

6
Pointer Arithmetic

• Increment / decrement pointers ( ++ or -- )


• Add / subtract an integer to/from a pointer
( + or += , - or -= )
• Pointers may be subtracted from each other
• Pointer arithmetic is meaningless unless
performed on an array

7
Pointer Arithmetic (Cont.)
• Example
Consider an integer array of 5 elements on a machine using 4
bytes for integers.
1000 1004 1008 1012 1016

V[0] V[1] V[2] V[3] V[4]

Pointer variable vPtr

- vPtr pointes to first element V[0] (location 1000)


i.e. vPtr = 1000
- vPtr +=2; sets vPtr to 1008
i.e. vPtr points to V[2]

8
Pointer Arithmetic (Cont.)

• Subtracting pointers
- Returns the number of elements between two
addresses

e.g. if v is an array and


vPtr1 = v[0];
vPtr2 = v[2];
then vPtr2 – vPtr1 = 2 (i.e. 2 addresses)

9
Relations Between Pointers and Arrays

• Arrays and pointers are closely related.


- Array name is like constant pointer
- Pointers can do array subscribing operations
- If we declare an array A[4] and a pointer aPtr
 aPtr is equal to A
aPtr == A
 aPtr is equal to the address of the first
element of A
aPtr == & A[0]

10
Relations Between Pointers and Arrays (Cont.)

• Accessing array elements with pointers:


- Element A[i] can be accessed by *(aPtr+i)
 This is called pointer/offset notation
- Array itself can use pointer arithmetic
 A[3] is same as *(A+3)
- Pointers can be subscripted
(i.e. pointer/subscript notation)
 aPtr [3] is same as A[3]

11
Examples on Pointers
//File: swap.cpp
//A program to call a function to swap two numbers using reference parameters

#include <iostream.h>
void swap(int *, int *); // This is swap's prototype
void main()
{ int x = 5, y = 7;
swap(&x , &y); // calling swap with reference parameters
cout << "\n x is now "<< x << " and y is now " << y << '\n';
}
// swap function is defined here using dereferencing operator ‘*’
void swap(int *a, int *b)
{ int temp;
temp = *a;
*a = *b;
*b = temp;
}
12
Examples on Pointers (Cont.)
//File: pointers.cpp
//A program to test pointers and references
#include <iostream.h>
void main ( )
{ int intVar = 10;
int *intPtr; // intPtr is a pointer
intPtr = & intVar;
cout << "\nLocation of intVar: " << & intVar;
cout << "\nContents of intVar: " << intVar;
cout << "\nLocation of intPtr: " << & intPtr;
cout << "\nContents of intPtr: " << intPtr;
cout << "\nThe value that intPtr points to: " << * intPtr;
}

13
When calling, the pointer formal parameter will points to the

.actual parameter
#include <iostream.h>
void Increment(int*);

void main() {
int A = 10;
Increment(&A);
cout<<A<<endl;
}

void Increment(int *X) { ++*X; }


14

You might also like