# t13 BPointers Pass By Reference

Document Sample

```					              Department of Computer and Information Science,
School of Science, IUPUI

CSCI 230

Pointers
Call-by-Reference
Dale Roberts, Lecturer
Computer Science, IUPUI
E-mail: droberts@cs.iupui.edu

Dale Roberts
Calling Functions by Reference
Call by reference with pointer arguments
Pass address of argument using & operator
Allows you to change actual location in memory
Arrays are not passed with & because the array name is already a
pointer

* Operator
Used as formal parameter for variable inside of function
void double_num ( int *number )
{
*number = 2 * ( *number );
}
*number used as nickname for the actual variable passed

Dale Roberts
Example of Calling Functions by Value
1      /*
2      Cube a variable using call-by-value
3      */
4
5 #include <stdio.h>
6
7 int cubeByValue( int );      /* prototype */                   Function prototype
8
9 int main()
10 {
11     int number = 5;                                           Initialize variables
12
13     printf( "The original value of number is %d", number );
14     number = cubeByValue( number );                           Call function
15     printf( "\nThe new value of number is %d\n", number );
16
17     return 0;
18 }
19
20 int cubeByValue( int n )
Define function
21 {
22     return n * n * n;   /* cube number in main */
23 }
The original value of number is 5                                Program Output
The new value of number is 125

Dale Roberts
Example of Calling Functions by Value
int main()                            number   int cubeByValue( int n )
{                                              {
int number = 5;                                                       n
5        return n * n * n;
number = cubeByValue( number );
}                                              }                          undefined

int main()                                     int cubeByValue( int n )
{                                     number   {                          n
int number = 5;                              return n * n * n;
number = cubeByValue( number );      5
}                              5
}

int cubeByValue( int n )
int main()                            number                              n
{
{
int number = 5;                      5        return n * n * n;           5
number = cubeByValue( number );            }             125
}

int main()                            number   int cubeByValue( int n )    n
{                                              {
int number = 5;                                                       undefined
5        return n * n * n;
number = cubeByValue( number );            }
}

int cubeByValue( int n )
int main()                            number   {                            n
{
int number = 5;                     125       return n * n * n;       undefined
number = cubeByValue( number );            }
}

Dale Roberts
Example of Calling Functions by Reference
1   /* Fig. 7.7: fig07_07.c
2     Cube a variable using call-by-reference
3     with a pointer argument */
4
5 #include <stdio.h>
6
Function prototype
7   void cubeByReference( int * );     /* prototype */
8
9 int main()                       Notice that the function prototype takes
a pointer to an integer ( int * ).
10 {
11     int number = 5;
12                                       Initialize variables
13     printf( "The original value of number is %d", number );
number is given -
14     cubeByReference( &number );       Call function                 cubeByReference expects
15     printf( "\nThe new value of number is %d\n", number );
a pointer (an address of a
16                                                                     variable).
17     return 0;
18 }                       Inside cubeByReference, *nPtr is used (*nPtr is number).
19
20 void cubeByReference( int *nPtr )
Define function
21 {
22     *nPtr = *nPtr * *nPtr * *nPtr;     /* cube number in main */
23 }
The original value of number is 5        Program Output
The new value of number is 125
Dale Roberts
Example of Calling Functions by Reference

Before the call by reference to cubeByReference:

int main()                                               void cubeByReference( int *nPtr )
{                                                        {                                   nPtr
int number = 5;                           number         *nPtr = *nPtr * *nPtr * *nPtr;
undefined
cubeByReference( &number );                           }
}                                                  5

After call by reference to cubeByReference and before *nPtr is cubed:
n
int main()                                               void cubeByReference( int *nPtr )
{                                                        {
int number = 5;                           number                                          nPtr
*nPtr = *nPtr * *nPtr * *nPtr;
}                                                  5     }
number

After *nPtr is cubed :

int main()                                               void cubeByReference( int *nPtr )
{                                                        {
int number = 5;                           number                                          nPtr
*nPtr = *nPtr * *nPtr * *nPtr;
cubeByReference( &number );                           }                                   address of
}                                                  125                                       number

Dale Roberts
Using the const Qualifier with Pointers
const qualifier
Variable cannot be changed
Use const if function does not need to change a variable
Attempting to change a const variable produces an error
const pointers                                  COMPUTER MEMORY
Point to a constant memory location     CONSTANT MEMORY AREA

Ptr     x3
Must be initialized when declared        case 3
1) int *const myPtr1 = &x1;                           myPtr1         x2
Type int *const
Constant pointer to an int                   case         case
1            2
x can be changed, but not *Ptr
2)   const int *myPtr2 = &x2;                               x1      myPtr2
Regular pointer to a const int                      myPtr        x
case with
3)   const int *const Ptr = &x3;            using const

const pointer to a const int       VARIABLE MEMORY AREA

Dale Roberts
1    /* Fig. 7.13: fig07_13.c
2        Attempting to modify a constant pointer to
3        non-constant data */
4
5    #include <stdio.h>
6
7    int main()
8    {
9        int x, y;                                                       Declare variables
10
11       int * const ptr = &x; /* ptr is a constant pointer to an        Declare const
12                                integer. An integer can be modified    pointer to an int
13                                through ptr, but ptr always points
14                                to the same memory location. */
15       *ptr = 7;                   Changing *ptr is allowed – x is     Change *ptr (which
16       ptr = &y;                   not a constant.                     is x)
17
18       return 0;                   Changing ptr is an error – ptr is
19 }                                 a constant pointer.                 Attempt to change
ptr
FIG07_13.c:
Error E2024 FIG07_13.c 16: Cannot modify a const object in
function main
*** 1 errors in Compile ***

Dale Roberts                      Output

```
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 1 posted: 5/29/2012 language: pages: 8
waheed anjum http://