Pointers on data structure in computer science.ppt

Introduction
 A pointer is a variable that represents the location (rather than the
value) of a data item, such as a variable or an array element.
 Pointers are used frequently in C, as they have a number of useful
applications.
 For example, pointers can be used to pass information back and
forth between a function and its reference point.
 In particular, pointers provide a way to return multiple data items
from a function via function arguments.
 Pointers also permit references to other functions to be specified as
arguments to a given function. This has the effect of passing
functions as arguments to the given function.
 Pointers are also closely associated with arrays and therefore
provide an alternate way to access individual array elements.
 Moreover, pointers provide a convenient way to represent
multidimensional arrays, allowing a single multidimensional array to
be replaced by a lower-dimensional array of pointers. This feature
permits a group of strings to be represented within a single array,

FUNDAMENTALS
 Suppose v is a variable that represents some particular
data items. The compiler will automatically assign
memory cells for this data item.
 The data item can then be accessed if we know the
location (i.e., the address) of the first memory cell.
 The address of v ’s memory location can be determined
by the expression &v, where & is a unary operator, called
the address operator, that evaluates the address of its
operand.
 Now let us assign the address of v to another variable,
pv.
 Thus, pv = &v
 This new variable is called a pointer to v, since it “points”
to the location where v is stored in memory.
 Remember, however, that pv represents v’s address, not

FUNDAMENTALS
 The data item represented by v (i.e., the data item stored
in v’s memory cells) can be accessed by the expression
*pv, where * is a unary operator, called the indirection
operator, that operates only on a pointer.
 Furthermore, if we write pv = &v and U = *pv, then U and
v will both represent the same value; i.e., the value of v
will indirectly be assigned to U. (It is assumed that U and
v are of the same data type.)

Example
 Shown below is a simple program that illustrates the
relationship between two integer variables, their
corresponding addresses and their associated pointers.

Example
 The relationships between pu and u, and pv and v, are
shown in the following figure. Note that the memory
locations of the pointer variables (i.e., address EC7 for
pu, and EC5 for pv) are not displayed by the program.

FUNDAMENTALS
 The address operator (&) must act upon operands that
are associated with unique addresses, such as ordinary
variables or single array elements.
 Thus the address operator cannot act upon
arithmetic expressions, such as 2 * (U + v).
 The indirection operator (*) can only act upon operands
that are pointers (e.g., pointer variables).
 However, if pv points to v (i.e., pv = &v), then an
expression such as *pv can be used interchangeably
with its corresponding variable v.
 Thus, an indirect reference (e.g., *pv) can appear in
place of an ordinary variable (e.g., v) within a more
complicated expression.

POINTER DECLARATIONS
 The variable name must be preceded by an asterisk (*).
 This identifies the fact that the variable is a pointer. The
data type that appears in the declaration refers to the
object of the pointer, i.e., the data item that is stored in
the address represented by the pointer, rather than the
pointer itself.
 Thus, a pointer declaration may be written in general
terms as
data- type *ptvar;
where ptvar is the name of the pointer variable, and data-
type refers to the data type of the pointer’s object.
Remember that an asterisk must precede ptvar.

FUNCTION
 Pointers are often passed to a function as arguments.
 We refer to this use of pointers as passing arguments by
reference (or by address or by location),in contrast to
passing arguments by value.
 Thus, the use of a pointer as a function argument
permits the corresponding data item to be altered
globally from within the function.

Example
 Here is a simple C program that illustrates the difference
between ordinary arguments, which are passed by value,
and pointer arguments, which are passed by reference.

Analyzing a Line of Text
 Let us write a complete C program that will carry out an
analysis on a line of text to count the no of vowels,
consonants, digits, whitespace characters and “other”
characters (punctuation, operators, brackets, etc.).
To do so, we first define the following symbols.
 line = an 80-element character array containing the line of
text
 vowels = an integer counter indicating the number of
vowels
 consonants = an integer counter indicating the number of
consonants
 digits = an integer counter indicating the number of digits
 whitespc = an integer counter indicating the number of
whitespace characters (blank spaces or tabs)

Contd…
 It is possible to pass a portion of an array, rather than an
entire array, to a function. To do so, the address of the
first array element to be passed must be specified as an
argument. The remainder of the array, starting with the
specified array element, will then be passed to the
function.

POINTERS AND ONE-DIMENSIONAL
ARRAYS
 Recall that an array name is really a pointer to the first
element in the array.
 Therefore, if x is a one dimensional array, then the
address of the first array element can be expressed as
either &x [ 0] or simply as x.
 Moreover, the address of the second array element can
be written as either &x [ 1 ] or as (x + 1), and so on.

ARRAYS

ARRAYS
Output:

ARRAYS
 On the other hand, it is sometimes necessary to assign
an address to an identifier.
 In such situations, a pointer variable must appear on the
left side of the assignment statement.
 It is not possible to assign an arbitrary address to an
array name or to an array element.
 Thus, expressions such as x, ( x + i) and &x [i] cannot
appear on the left side of an assignment statement.
 Moreover, the address of an array cannot arbitrarily be
altered, so that expressions such as ++x are not
permitted.
 On the other hand, we can assign the value of one array
element to another through a pointer if we wish, e.g., pl =
&line[l];

ARRAYS
 Strings can be assigned to pointer variables rather than
to one dimensional arrays.

ALLOCATION
 Since an array name is actually a pointer to the first
element within the array, it should be possible to define the
array as a pointer variable rather than as a conventional
array.
 Syntactically, the two definitions are equivalent. However,
a conventional array definition results in a fixed block of
memory being reserved at the beginning of program
execution, whereas this does not occur if the array is
represented in terms of a pointer variable.
 Therefore, the use of a pointer variable to represent an
array requires some type of initial memory assignment
before the array elements are processed. This is known as
dynamic memory allocation.
 Generally, the malloc library function is used for this

DYNAMIC MEMORY ALLOCATION
 An important advantage of dynamic memory allocation is
the ability to reserve as much memory as may be required
during program execution, and then release this memory
when it is no longer needed.
 Moreover, this process may be repeated many times
during execution of a program. The library functions malloc
and free are used for these purposes.

OPERATIONS ON POINTERS
 Suppose, for example, that px is a pointer variable that
represents the address of some variable x.
 We can write expressions such as ++px, - - px, (px + 3 ) ,
(px + i),and (px - i),where i is an integer variable.
 Each expression will represent an address that is located
some distance from the original address represented by
px.

OPERATIONS ON POINTERS
The operations that can be carried out on pointers are
summarized below-
1. A pointer variable can be assigned the address of an
ordinary variable (e.g., pv = &v).
2. A pointer variable can be assigned the value of another
pointer variable (e.g., pv = px) provided both pointers point
to objects of the same data type .
3. A pointer variable can be assigned a null (zero) value
(e.g., pv = NULL, where NULL is a symbolic constant that
represents the value 0).
4. An integer quantity can be added to or subtracted from a
pointer variable (e.g., pv + 3, ++pv, etc.)
5. One pointer variable can be subtracted from another
provided both pointers point to elements of the same array.

POINTERS AND MULTIDIMENSIONAL
ARRAYS
 We can define a two-dimensional array as a pointer to a
group of
 contiguous one-dimensional arrays.
 Thus, a two-dimensional array declaration can be written
as
 data- type ( *ptvar) [ expression 2] ;
rather than
data- type array[ expression I] [ expression 2];
 This concept can be generalized to higher-dimensional
arrays; that is,
data- type ( *ptvar)[ expression 21 [ expression 31 . . . [
expression n] ;
replaces

ARRAYS OF POINTERS
 A multidimensional array can be expressed in terms of an array of pointers
rather than a pointer to a group of contiguous arrays.
 In such situations the newly defined array will have one less dimension than
the original multidimensional array. Each pointer will indicate the beginning
of a separate (n- 1)-dimensional array.
 In general terms, a two-dimensional array can be defined as a one-
dimensional array of pointers by writing-
 data - type *array[ expression 7 ) ;
rather than the conventional array definition,
 data- type array[ expression 7 ] [ expression 21 ;
 Similarly, an n-dimensional array can be defined as an (n - 1)-dimensional
array of pointers by writing-
 data- type *array[ expression 71 [ expression 2) . . . [ expression n- 71 ;
rather than
 data- type array[ expression I ] [ expression 21 . . . [ expression n] ;

PASSING FUNCTIONS TO OTHER
FUNCTIONS
 A pointer to a function can be passed to another function
as an argument.
 This allows one function to be transferred to another, as
though the first function were a variable.
 Let us refer to the first function as the guest function, and
the second function as the host function. Thus, the guest
is passed to the host, where it can be accessed.
 Successive calls to the host function can pass different
pointers (i.e., different guest functions) to the host.

Pointers on data structure in computer science.ppt

More Related Content

What's hot

Similar to Pointers on data structure in computer science.ppt

Recently uploaded

Pointers on data structure in computer science.ppt