iit c prog.ppt

Lectures on Numerical Methods 1
Address of a variable
Each variable that is declared is
stored in memory. Since memory is
indexed each variable has an
address.
C allows programmers to access
the address of the variables.
Unary operator & (read as ‘address
of’) gives the address of the
operand variable.
See example.
Since constants, expressions do
not have permanent storage, they
donot have address.
&1.0, &(d+6) are illegal.
See printf format.
#include <stdio.h>
#define line "t-----------------n"
main()
{
int i = 0;
char c = 'a';
short s = 1;
long l = 2;
float f = 3.0;
double d = 4.0;
printf("Variable Tablen");
printf(line);
printf("tVarttAddressttValuen");
printf(line);
printf("t%stt%pt%dn","i", &i, i);
printf("t%stt%pt%cn","c", &c, c);
printf("t%stt%pt%dn","s", &s, s);
printf("t%stt%pt%dn","l", &l, l);
printf("t%stt%pt%fn","f", &f, f);
printf("t%stt%pt%fn","d", &d, d);
printf(line);
}

Address of a variable
This program was compiled by gcc on
linux machine.
The output of this program:
Variable Table
-------------------------------
Var Address Value
-------------------------------
i 0xbffffc94 0
c 0xbffffc93 a
s 0xbffffc90 1
l 0xbffffc8c 2
f 0xbffffc88 3.000000
d 0xbffffc80 4.000000
-------------------------------
#include <stdio.h>
#define line "t-----------------n"
main()
{
int i = 0;
char c = 'a';
short s = 1;
long l = 2;
float f = 3.0;
double d = 4.0;
printf("Variable Tablen");
printf(line);
printf("tVarttAddressttValuen");
printf(line);
printf("t%stt%pt%dn","i", &i, i);
printf("t%stt%pt%cn","c", &c, c);
printf("t%stt%pt%dn","s", &s, s);
printf("t%stt%pt%dn","l", &l, l);
printf("t%stt%pt%fn","f", &f, f);
printf("t%stt%pt%fn","d", &d, d);
printf(line);
}

Pointer to a variable
If variables have addresses, can
these be stored in the variables
and manipulated with?
These addresses have a new data-
types (derived data-types) called
pointers.
Pointers are declared as
data-type *var-name;
In this example one pointer
variable has been declared as p
and it can store addresses of any
integer variables.
#include <stdio.h>
#define line "t----------------n"
main()
{
int i = 0;
int j = 1;
int k = 2;
float f = 3.0;
int *p = 0;
p = &k;
printf("p = %ptt*p = %dn", p, *p);
j = *p + 5;
printf(“j = %dtt*p = %dn", j, *p);
*p = *p + i;
p = &f;
}

The simplest operation is to get an
address of a variable and store it in
a pointer variable.
Example
p = &k;
p = &f;
Pointer p is declared to store an
address of an int variable.
Assigning an address of a float
variable to p, would cause a
compiler warning or error.
(Continuing in spite of warning,
may result in disaster).
#include <stdio.h>
#define line "t----------------n"
main()
{
int i = 0;
int j = 1;
int k = 2;
float f = 3.0;
int *p = 0;
p = &k;
j = *p + 5;
*p = *p + i;
p = &f;
}

The value of pointer p is an
address of some int variable.
The value of the int variable
pointed to by p can be accessed by
using a dereferencing operator *.
Printf statement here prints the
value of p and that of *p.
p = 0xbffffc8c *p = 2
*p is just like k here. All
expressions where k can appear,
*p also can.
j = 7 *p = 2
#include <stdio.h>
#define line "t----------------n"
main()
{
int i = 4;
int j = 1;
int k = 2;
float f = 3.0;
int *p = 0;
p = &k;
j = *p + 5;
*p = *p + i;
p = &f;
}

The dereferencing operator *p is
not only used to get the value of
the variable pointed to by p, but
also can be used to change the
value of that variable.
It is legal to use *p as left side of an
assignment.
P = 0xbffffc8c *p = 6
#include <stdio.h>
#define line "t----------------n"
main()
{
int i = 0;
int j = 1;
int k = 2;
float f = 3.0;
int *p = 0;
p = &k;
j = *p + 5;
*p = *p + i;
p = &f;
}

Pointer Arithmetic
A simple arithmetic is allowed for
the pointers.
A pointer points a variable of a
given type. When we add 1 to a
pointer variable, it points to the
next variable in the memory(though
it may not be of the same type).
Here p = p + 1 would cause the
value of p to be added 4 which is
size of int.
Look at output.
#include <stdio.h>
#define line "t----------------n"
main()
{
int i = 0;
int j = 1;
int k = 2;
int *p = 0;
p = &k;
p = p + 1;
p++ ;
p = &f;
}

Pointer Arithmetic
Variable Table
----------------------------------------
Var Address Value
----------------------------------------
i 0xbffffc94 0
j 0xbffffc90 1
k 0xbffffc8c 2
f 0xbffffc88 3.000000
p 0xbffffc84 (nil)
----------------------------------------
The output of this program is given here.
p = 0xbffffc8c *p = 2
p = 0xbffffc90 *p = 1
p = 0xbffffc94 *p = 0
p = 0xbffffc88 *p = 1077936128

Pointers and Functions Arguments
 We have seen that since a and b are
passed by value to swap1 function,
the values of a and b in main are not
swapped.
 But in swap2, the address of a and
address of b is passed. Hence pa and
pb contains the addresses of a and b.
Then the changes are made directly
to the locations of a and b.
 The result would be
3 5
5 3
void swap1(int a, int b) {
int temp = a;
a = b;
b = temp;
}
void swap2(int *pa, int *pb) {
int temp = *pa;
*pa = *pb;
*pb = temp;
}
main() {
int a = 3, b = 5;
swap1(a, b);
printf(“%dt%d”, a, b);
swap2(&a, &b);
printf(“%dt%d”, a, b);
}

Pointers and Functions Arguments
 It is indeed inconvenient that a function can return only one value.
 Consider a function for the bisection method. The function is expected to
return a root of a function.
double getRoot(double l, double r, double tol, int maxIter);
 What would happen if the root is not bracketed in [l,r] interval? The function
is still likely to return some value which is not the required root. Ideally,
there should be one more variable indicating the error.
double getRoot(double l, double r, double tol, int maxIter, int
*error);

Pointers and Arrays
An array name is a constant pointer. So if a is an array of 10 integers
and pa is a pointer to int variable, then
Pa = &a[0];
Pa = a;
Are legal and same. So are
B = a[5];
B = *(a+5);
However since a is constant pointer following is invalid
A = pa;

iit c prog.ppt

Recommended

More Related Content

Similar to iit c prog.ppt (20)

Recently uploaded (20)

iit c prog.ppt