POINTERS IN C MRS.SOWMYA JYOTHI.pdf

POINTERS
REFERENCE: PROGRAMMING IN C BY BALAGURUSWAMY
MRS. SOWMYA JYOTHI, SDMCBM, MANGALORE

Introduction:
In C language, a pointer is a variable that points to or
references a memory location in which data is stored.
Each memory cell in the computer has an address which can
be used to access its location.
A pointer variable points to a memory location. By making
use of pointer, we can access and change the contents of the
memory location.
Pointers contain memory addresses as their values.

What are Pointers?
A pointer is a variable whose value is the
address of another variable, i.e., direct
address of the memory location
Like any variable or constant, you must
declare a pointer before using it to store any
variable address.
The purpose of pointer is to save memory
space and achieve faster execution time.

How to Use Pointers?
There are a few important operations, which we will do
with the help of pointers very frequently.
(a) We define a pointer variable,
(b) Assign the address of a variable to a pointer and
(c) Finally access the value at the address available in
the pointer variable. This is done by using unary
operator * that returns the value of the variable located
at the address specified by its operand.

Pointer declaration:
A pointer variable contains the memory location
of another variable. We begin the declaration of a
pointer 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 pointer variable.

The general form of a pointer variable declaration is
type * variablename
Here, type is the pointer's base type; it must be a valid
C data type and variablename is the name of the
pointer variable.
The asterisk * used to declare a pointer is the same
asterisk used for multiplication. However, in this
statement the asterisk is being used to designate a
variable as a pointer.

Example:
int *ptr;
float *string;
Tells that the variable ptr is a pointer variable
ptr needs a memory location
ptr points to a variable of integer type

int *ip; /* pointer to an integer */
double *dp; /* pointer to a double */
float *fp; /* pointer to a float */
char *ch /* pointer to a character */
The actual data type of the value of all pointers,
whether integer, float, character, or otherwise, is the
same, a long hexadecimal number that represents a
memory address.

#include <stdio.h>
void main ()
{
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
ip = &var; /* store address of var in pointer variable*/
printf("Address of var variable: %xn", &var );
/* address stored in pointer variable */
printf("Address stored in ip variable: %xn", ip );
/* access the value using the pointer */
printf("Value of *ip variable: %dn", *ip );
} Address of var variable: bffd8b3c
Address stored in ip variable: bffd8b3c
Value of *ip variable: 20

NULL Pointers
It is always a good practice to assign a NULL value to a
pointer variable in case you do not have an exact address to
be assigned.
This is done at the time of variable declaration.
A pointer that is assigned NULL is called a null pointer.
The NULL pointer is a constant with a value of zero defined
in several standard libraries.

#include <stdio.h>
int main ()
{
int *ptr = NULL;
printf("The value of ptr is : %xn", ptr);
return 0;
}
The value of ptr is 0
But by convention, if a pointer contains the null (zero) value, it is

Initialize a pointer using Address operator:
After declaring a pointer, we initialize it like standard variables with a
variable address.
To get the address of a variable, we use the ampersand (&)operator,
placed before the name of a variable whose address we need.
Once we declare a pointer variable, we point the variable to another
variable.
We can do this by assigning the address of the variable to the pointer
as in the following example:
◦ptr=&num;
The operator & immediately preceding a variable returns the address of
the variable associated with it.

ptr=&num;
The above declaration places the memory
address of num variable into the pointer
variable ptr.
If num is stored in memory 1260 address then
the pointer variable ptr will contain the
memory address value 1260.

Pointer Variable
int *y = &v;
Instead of storing a value, a pointer y will store the
address of a variable.

#include <stdio.h>
int main()
{
int a=10; //variable declaration
int *p; //pointer variable declaration
p=&a; //store address of variable a in pointer p
printf("Address stored in a variable p is:%xn",p);
//accessing the address
printf("Value stored in a variable p is:%dn",*p);
//accessing the value
return 0;
}

/* A program to illustrate pointer declaration */
main()
{
int *ptr;
int sum;
sum=45;
ptr=∑
printf (“n sum variable value is %dn”, sum);
printf (“n The 'ptr' pointer variable value is %d”, ptr);
}

What is a scaling factor in C?
Scale factor is the quantity of increment in the value of a
pointer on adding the Data Type.
when we increment a pointer, its value is incremented by the
length of the data type that it points to . This length is called
the scale factor.

POINTERS IN C MRS.SOWMYA JYOTHI.pdf

More Related Content

What's hot (20)

Similar to POINTERS IN C MRS.SOWMYA JYOTHI.pdf (20)

Recently uploaded (20)

POINTERS IN C MRS.SOWMYA JYOTHI.pdf