Pointers

Variable
A variable is a named memory location. Variables provide direct access to its memory location. A variable has a name, an address, a type,and a value: "the name identifies the variable to the programmer "the address specifies where in main memory the variable is located

What is a variable?
"the type specifies how to interpret the data stored in main memory and how long the variable is "the value is the actual data stored in the variable after if has been interpreted according to a given type

Pointer variable

A pointer is a variable that contains the memory location of another variable. Syntax:type * variable name You start by specifying the type of data stored in the location identified by the pointer. The asterisk tells the compiler that you are creating a pointer variable. Finally you give the name of the variable.

Declaring a Pointer Variable

To To

declare ptr as an integer pointer: declare ptr as a character pointer:

int *ptr;
char *ptr;

Address operator:
Once we declare a pointer variable we must point it to something we can do this by assigning to the pointer the address of the variable you want to point as in the following example: ptr=# This places the address where num is stores into the variable ptr. If num is stored in memory 21260 address then the variable ptr has the value 21260.

Address and Pointers

Memory can be conceptualized as a linear set of data locations. Variables reference the contents of a locations Pointers have a value of the address of a given location

ADDR1 ADDR2 ADDR3 ADDR4 ADDR5 ADDR6 * * * ADDR11 Contents1

Contents11

* *
ADDR16 Contents16

Lect 14

P. 7

Pointer Variable
Assume ptr is a pointer variable and x is an integer variable x 10

ptr &x Now ptr can access the value of x.

x = 10 ptr = &x

HOW!!!! Write: *variable . Cout<< *ptr; For example:

Variables, Addresses and Pointers

main()

{ int a = 5; int b = 6; int *c; // c points to a c = &a; }

Memory Value a (1001) b (1003) c (1005) 1001

5 6

include< stdio.h > { int num, *intptr; float x, *floptr; char ch, *cptr; num=123; x=12.34; ch=a; intptr=&num; cptr=&ch; floptr=&x; cout<<Num <<*intptr,<< stored at address <<intptr; cout<<Value <<*floptr << stored at address <<floptr; cout<<Character <<*cptr <<stored at address<<cptr; }

Run this code

int main() { int x; int *ptr;

x = 10; ptr = &x; *ptr = *ptr + 1; cout<< x; return 0; }

Manipulating Pointer Variable

Once a variable is declared, we can get its address by preceding its name with the unary & operator, as in &k. We can "dereference" a pointer, i.e. refer to the value of that which it points to, by using the unary '*' operator as in *ptr

Reference

Reference & Retrieve the memory address of a variable int a = 6; int* c = &a; // &a is the memory location of variable a

Dereference

Dereference * Accessing the variable (content) the pointer points to (Indirection) int a = 6; int* c = &a; *c = 7; /* Changes content of variable a by using its address stored in pointer c */ equivalent to a = 7;

Constant Pointers
A constant pointer, ptr, is a pointer that is initialized with an address, and cannot point to anything else. We can use ptr to change the contents of value Example int value = 22; int * const ptr = &value;

CIS 15 Pointer Arithmetic

15

Constant Pointer
Constant pointer means the pointer is constant. Constant pointer is NOT pointer to constant. For eg: int * const ptr2 indicates that ptr2 is a pointer which is constant. This means that ptr2 cannot be made to point to another integer. However the integer pointed by ptr2 can be changed.

//const pointer void main() { int i = 100,k; int* const pi = &i; *pi = 200; pi=&k; //won't compile }

Constant Pointers to Constants

A constant

pointer to a constant is:

a pointer that points to a constant a pointer that cannot point to anything except what it is pointing to
Example:

int value = 22; const int * const ptr = &value;

CIS 15 Pointer Arithmetic 18

//const pointer to a const void f3() { int i = 100; const int* const pi = &i; //*pi = 200; <- won't compile //pi++; <- won't compile }

Pointer to constant
Pointer to constant is const int * ptr1 indicates that ptr1 is a pointer that points to a constant integer. The integer is constant and cannot be changed. However, the pointer ptr1 can be made to point to some other integer.

//pointer to a const void f1() { int i = 100; const int* pi = &i; //*pi = 200; <- won't compile pi++; }m

Pointer arithmetic
Valid operations on pointers include: - the sum of a pointer and an integer - the difference of a pointer and an integer - pointer comparison -the difference of two pointers. -Increment/decrement in pointers - assignment operator used in pointers

Example
void main() { int a=25,b=78,sum; int *x,*y; x=&a; y=&b; sum= *x + *y; cout<<Sum is : <<sum; }

Assignment in pointers

Pointer variables can be "assigned":

int *p1, *p2; p2 = p1; Assigns one pointer to another "Make p2 point to where p1 points"

Do not confuse with:

*p1 = *p2; Assigns "value pointed to" by p1, to "value pointed to" by p2

Diagrammatic representation

Comparison in pointers

Two pointers of the same type, p and q, may be compared as long as both of them point to objects within a single memory block Pointers may be compared using the <, >, <=, >=, == , != When you are comparing two pointers, you are comparing the values of those pointers rather than the contents of memory locations pointed to by these pointers

Increment and decrement

Data Type Initial address 4046 4053 4050 4060 Operation Address after operation s 4048 4054 4054 4064 4044 4042 4046 4056 Required bytes 2bytes 1bytes 4bytes 4bytes Int i=2 Char c=x Float f=2.2 Long l=2 ++ ++ ++ ++ -----

You can perform a limited number of arithmetic operations on pointers. These operations are: Increment and decrement Addition and subtraction Comparison Assignment The increment (++) operator increases the value of a pointer by the size of the data object the pointer refers to. For example, if the pointer refers to the second element in an array, the ++ makes the pointer refer to the third element in the array. The decrement (--) operator decreases the value of a pointer by the size of the data object the pointer refers to. For example, if the pointer refers to the second element in an array, the -- makes the pointer refer to the first element in the array.

You can add an integer to a pointer but you cannot add a pointer to a pointer. If the pointer p points to the first element in an array, the following expression causes the pointer to point to the third element in the same array: p = p + 2; If you have two pointers that point to the same array, you can subtract one pointer from the other. This operation yields the number of elements in the array that separate the two addresses that the pointers refer to. You can compare two pointers with the following operators: ==, !=, <, >, <=, and >=. Pointer comparisons are defined only when the pointers point to elements of the same array. Pointer comparisons using the == and != operators can be performed even when the pointers point to elements of different arrays. You can assign to a pointer the address of a data object, the value of another compatible pointer or the NULL pointer.

Pointer Arithmetic

Operations on pointer variables:

Example
int vals[]={4,7,11}; int *valptr = vals; valptr++; // points at 7 valptr--; // now points at 4 cout << *(valptr + 2); // 11 valptr = vals; // points at 4 valptr += 2; // points at 11

Operation
++, -+, - (pointer and int) +=,-= (pointer and int)

CIS 15 Pointer Arithmetic

30

Generic pointers
When a variable is declared as being a pointer to type void it is known as a generic pointer. Since you cannot have a variable of type void, the pointer will not point to any data and therefore cannot be dereferenced. It is still a pointer though, to use it you just have to typecast it to another kind of pointer first. Hence the term Generic pointer.

This is very useful when you want a pointer to point to data of different types at different times.
Syntax:
void * variable name; Print value stored in variable *(data_type*)name of variable;

void main() { int i; char c; void *data; i = 6; c = 'a'; data = &i; cout<<"the_data points to the integer value << *(int*) data; data = &c; cout<<"the_data now points to the character << *(char*) data; }

Null Pointer
NULL value can be assigned to any pointer, no matter what its type. void *p = NULL; int i = 2; int *ip = &i; p = ip; cout<<*p; cout<<*((int*)p ) ;

Pointers and Arrays

The concept of array is very much bound to the one of pointer. In fact, the identifier of an array is equivalent to the address of its first element, as a pointer is equivalent to the address of the first element that it points to, so in fact they are the same concept.

Pointers and Arrays

Pointers have close relationship with array . An array name by itself is an address or pointer. Pointers are linked with both types of array

A)one dimensional array pointer B)two dimensional array pointer

For example, int numbers [20]; int * p; The following assignment operation would be valid: p = numbers;

After that, p and numbers would be equivalent

and would have the same properties. The only

difference is that we could change the value of

pointer p by another one, whereas numbers

will always point to the first of the 20 elements

of type int with which it was defined. Therefore,

unlike p, which is an ordinary pointer, numbers

is an array, and an array can be considered a

constant pointer.

#include <iostream.h> main () { int numbers[5]; int * p; p = numbers; *p = 10; p++; *p = 20; p = &numbers[2];

Cont

cont.

*p = 30; p = numbers + 3; *p = 40; p = numbers; *(p+4) = 50; for (int n=0; n<5; n++) cout<<numbers[n]; }

In arrays we used brackets ([]) several times in order to specify the index of an element of the array to which we wanted to refer. Well, these bracket sign operators [] are also a dereference operator known as offset operator. They dereference the variable they follow just as * does, but they also add the number between brackets to the address being

For example: a[5] = 0; // a [offset of 5] = 0 *(a+5) = 0; // pointed by (a+5) = 0

These two expressions are equivalent and valid both if a is a pointer or if a is an array.

Example of 1D array
Void main() { int a[5]={1,2,3,4,5}; int *p,i; p=&a; cout<<displaying data using pointer ; for(i=0;i<5;i++) { cout<<*(p+i); } cout<<displaying data using array name ; for(i=0;i<5;i++) { cout<<*(a+i); }

Example of 2D array
Void main() {

int a[5][2]={ {1,2},{3,4},{5,6},{7,8},{9,10} };

int *p,j,i; p=&a; cout<<displaying data using pointer ;

for(i=0;i<5;i++)
{ for(j=0;i<2;j++) {

cout<<*(*(a+i)+j);
} cout<<\n; }

Pointers and Character String

void main() { char name[] = alex; char *ptr; int i=0;count=0; ptr=&name; while(*(ptr+i)!=\0) { count++; i++; } cout<<length of string is <<count; getch();

Example
void main() { char str1[]=hello; char str2[10]; char *s= Good Morning; char *q;
str2=str1; /error/ q= s; /works/ return; }

Array of pointers

It is nothing but a collection of address.

Void main()

{
int a[5]={1,2,3,4,5},i; int *p[5]; for(i=0;i<5;i++)

{
p[i]=a+i; } for(i=0;i<5;i++)

{
cout<<*(p+i)<<value; cout<<at location <<p+I; }

Pointers to pointers
A pointer variable containing address of another pointer variable is called pointer to pointer void main() { int a=2, *p, **q; p=&a; q=&p; cout<<a<<is stored at <<p<<and pointer is stored at <<q;}

Difference between *p[3] and (*p)[3] *p[3] declares p as an array of 3 pointers (*p)[3] declares p as a pointer to an array of 3 elements *(p+2)

What is this pointer?

Every object has a special pointer "this" which points to the object itself. This pointer is accessible to all members of the class but not to any static members of the class. Can be used to find the address of the object in which the function is a member. Presence of this pointer is not included in the sizeof calculations.

class MyClass { int data; public: MyClass() {data=100;}; void Print1(); void Print2(); };

// Not using this pointer void MyClass::Print1() { cout << data << endl; } // Using this pointer void MyClass::Print2() { cout << "My address = " << this << endl; cout << this->data << endl; }

int main() { MyClass a; a.Print1(); a.Print2(); // Size of doesn't include this pointer cout << sizeof(a) << endl; }

OUTPUT: 100 My address = 0012FF88 100 4

Pointer to derived class object

Class base1 { Public: Void display() { Cout<<base class displayed; } }; Class der1:public base1 { Public: Void display() {cout<<derived class displayed;} };

Void main() { base1 *ptr; der1 d; ptr=&d; ptrdisplay(); getch() } Output Base class displayed

Virtual function

It is the member function declared in the base class using the key word virtual. whose functionality redefined in the derived class.

Class base1 { Public: Virtual Void display() { Cout<<base class displayed; } }; Class der1:public base1 { Public: Void display() {cout<<derived class displayed;} };

Void main() { base1 *ptr; der1 d; ptr=&d; ptrdisplay(); getch() } Output derived class displayed

Pure Virtual Function

Is a function without a body Is created by adding the notation =0 to the virtual function declaration Example: virtual int calc_net_salary()=0;

class shape { protected: int a,b; public: void read() { cin>>a>>b; } virtual void cal_area()=0; };

class rectangle:public shape { void cal_area() { doubles area=a*b; cout<<area; } };

class triangle:public shap { void cal_area() { doubles area=(a*b)/2; cout<<area; } };

int main() { shape *ptr[2]; rectangle r1; cout<<enter leng n bredth; r1.read(); triangle t1; cout<<enter base n perpendicular; t1.read(); prt[0]=&r1; ptr[1]=&t1; for(int i=0;i<2;i++) ptr[i]->cal_area(); }

Enter leng and breadth 10 20 Enter base and perpendicular 5 20 Area of rectangle=200 Area of trinagle=50