Scribd
Upload
15 views15 pages

Pointers

A pointer holds the address of another variable. The & operator returns the address of a variable, and the * operator dereferences a pointer to access the value at that address. Pointers allow accessing and modifying the value of a variable indirectly through its address. Common uses of pointers include passing arguments by reference, dynamically allocating memory, and implementing arrays and structures.

Uploaded by

beshahashenafe20
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
15 views15 pages

Pointers

A pointer holds the address of another variable. The & operator returns the address of a variable, and the * operator dereferences a pointer to access the value at that address. Pointers allow accessing and modifying the value of a variable indirectly through its address. Common uses of pointers include passing arguments by reference, dynamically allocating memory, and implementing arrays and structures.

Uploaded by

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

Chapter-3

Pointers
Pointer
• A pointer is a variable that holds the address of
something else.
• The only difference between pointer variable and regular variable is the data
they hold.
• There are two pointer operators in C++:

• & the address of operator


• * the dereference operator
• We are going to suppose that var has been placed in the memory address
• 1776 and that we write the following:

• var=25; x=var;
• ptr = &var;
• Syntax :
dataType *identifier;
e.g.
int *x;
x is a pointer to an integer.
• Addresses: garbage, something, nothing
• When created:
int * q;
q = 0; // now it points to nothing
q = NULL; // not portable, use 0 instead
Pointers to anything
x some int
int *x;

z some double
double *z;

int **y;
y some *int some int
• To assign a value to the pointer variable
• use the address operator &
• E.g. MEMORY
int foo; Address

int *x; 0
1
2
foo = 123;
foo 3 123
x = &foo;
4
5

...

...
x 81345 3
81346
81347
&foo
In C++ you can get the address of a variable with the
“&” operator.

MEMORY
int foo; Address
0
1
foo = 123; 2
x = &foo; foo 3 123
4
5
• &foo means “the address of foo”

...

...
• Must always refer to something
• Must be initialized, cannot be changed
Dereferencing operator
• To assign a value to the variable foo through the
pointer variable
• we must use the dereferencing operator *
• E.g
*x=10;
//Changes the vale of foo from 123 to 10
Equivalent to
foo=10;
• You can use the integer x points to in a C++
expression like this:
y = *x + 17;

*x = *x +1;
#include <iostream.h>
int main() {
int *ptr_a, *ptr_b;
int num_c = 4, num_d = 7;
ptr_a = &num_c;
ptr_b = ptr_a;
cout << *ptr_a << " " << *ptr_b << "\n";
ptr_b = &num_d;
cout << *ptr_a << " " << *ptr_b << "\n";
*ptr_a = *ptr_b;
cout << *ptr_a << " " << *ptr_b << "\n";
cout << num_c << " " <<
*&*&*&num_c << "\n";
return 0; }
• The output of this program is:
• 44
• 47
• 77
• 77
More Pointers
int i = 50;
•
int j = 75;
int *p1 ; int * p2
p1 = &i ; p2 = & j;
cout << *p1;
p1 = p2 ; *p2 =0;
cout <<*p1;
Assigning a value to a
dereferenced pointer
A pointer must have a value before you can dereference
it (follow the pointer).

int *x; int foo;


*x=3; int *x;
x = &foo;
ing !!!
OR !!! o a ny th *x=3;
ERR po i ntt
do e sn’t fine
x i s is
th to fo o
p o in ts
x
Location and Value Comparisons
• Pointers may be compared for equality
• Same as comparing addresses of what pointers point to
(memory locations:)
• Contents of what pointers point to may be compared, too
• First implies second, not other way around

int
*p
0xefffdad0
5 p == &*p ==
int i int q &*q
*q
0xefffdbd0
5
*p ==
int j
*q
Const Pointers and Pointers to Const Types
• Make promises via the const keyword in
int main ( ){ pointer declaration:
const int i = 0; • not to change pointer itself
int j = 1; • not to change value it aliases
int k = 2; • can also promise neither/both
// pointer to int
• Read declarations right to left
int * w = &j; • In this example, can change
• w and what it points to
// const pointer to int • what x points to but not x
int * const x = &k; • y but not what it points to
• neither z nor what it points to
// pointer to const int • A pointer to a non-const type cannot point
const int * y = &i; to a const variable
• w and x can’t point to i
// const pointer to const int
const int * const z = &j;
}
Pointers and arrays
• The name of an array is a pointer to the 0th element of
the array (the beginning of the array)

int array[5] ;
// array is equivalent to & array[0]
*array = 5; is like array[0] = 5;
int j = *(array+4) is like int j = array[4]
cout << *array; is like cout << array[0];
Pointers and Arrays
• An array name is basically a const pointer.
• You can use the [] operator with a pointer:

int *x;
int a[10];
x = &a[2]; x is “the address of a[2]
for (int i=0;i<3;i++)
”
x[i]++;

x[i] is the same as


a[i+2]
Pointers
• Summary
• &p, p, and *p all have different meanings
• &p means the address of p
• p means the content of p
• *p means the content pointed to by p, that is pointed to
by the content of memory location

You might also like