Root: 1 revision(s)

2007-06-08T15:04:45Z

1 revision(s)

← Older revision	Revision as of 15:04, 8 June 2007
(No difference)

Root: /* Passing functions as pointers */

2007-06-08T13:07:13Z

Passing functions as pointers

New page

=Pointers=
The concept of pointers in a simple one; however, in old [http://en.wikipedia.org/wiki/C_language C language] the pointers are perhaps the single most common cause of program failure in code written by novice programmers. A good way to start, eh? Well.. pointers can be trouble makers, but the good news is, unlike in C, with C++ there many ways to avoid using them. Before we go any further, the rule of the game of pointers (at least for the 'rest of us') is '''don't use them unless absolutely necessary'''.

Having said that, using 'Pointers' for essential tasks is not difficult, and the rules that govern how they work are pretty simple. The rules can be combined to get complex results, but the individual rules remain simple.

Before we go any further, lets define what a `pointer' is.
;Pointer:A pointer is a programming language data type whose value refers directly to (or “points to”) another value stored elsewhere in the computer memory using its address.

A good analogy is the relationship between a web page and its URL (address). For example <tt><nowiki>http://en.wikipedia.org/wiki/Banana</nowiki></tt> is URL of the page describing Bananas on Wikipedia. If we know the above address it allows us to reach the ''Banana Page''. However, <tt><nowiki>http://en.wikipedia.org/wiki/Banana</nowiki></tt> is not the ''Banana Page'', but only the <tt><nowiki>address</nowiki></tt> of that page.

Similarly a pointer in computer jargon is a reference (or address) of something.

===Pointers and Pointees===

Remember this: Addresses are pointers. The stuff referred to by those addresses (''Banana Page'' in case of <tt><nowiki>http://en.wikipedia.org/wiki/Banana</nowiki></tt> or your home, in case of your postal address.) is pointee.

In C/C++ we denote this as follows:
<source lang=cpp>
/* Pointer/ Pointee demo */
#include<iostream>
using namespace std;
int main(){
int *k; // the pointee of k is an integer.
int y; // y is an integer
y=0; // set y to zero
k=&y; // point k to the address of y (y is pointee of k now)
*k=40; // set the value of pointee of k (ah, ha!) to 40.
cout << y <<"\n"; // print y.
cout << (*k) <<"\n"; // print pointee of k
}
</source>

The notation <tt><nowiki>*</nowiki></tt> can be read as '''''pointee of''''' and <tt><nowiki>&</nowiki></tt> as '''''address of'''''.

What <tt><nowiki> k=&y; *k=40; </nowiki></tt> does is equivalent of <tt><nowiki>y=40</nowiki></tt> in a very round about way!! This code shows one of the major issues of pointer usage. Where there are pointers -- there are hidden links. If we don't keep a track of these links, we are inviting for trouble!

If you are interested in a more in-depth coverage of the pointers in general make a detour to [[C++ Pointers -- Advanced|this link]]. The rest of this article covers only two important aspects of pointers.

==Using Pointers to get values out of functions==
The most straight forward way to get the results of a function is its return value. If you need to get several values out of a function how do you do that? One way is to use [[#Data_Structures|Data Structures]], a topic we are yet to cover. Another is to use pointers. See the following example:

<source lang=cpp>
#include <iostream>
using namespace std;
void add(int *a){ // pointee of a is an integer
(*a)+=5; // add 5 to pointee of a
}

int main ()
{
int val=0; // val is zero
int *k; // k's pointee is an integer.
k=&val; //now k points to the address of val
add(k); // pass k, i.e. address of val
cout << val; // val has changed!
}

</source>

The following section is a formal explanation of what is happening.

===Passing ''by value'' or ''by reference''===

All the simple functions we have seen in section [[#Functions|Functions]] and thereafter, the arguments passed to the functions have been passed ''by value''. This means that when calling a function with parameters, what we have passed to the function were copies of their values but never the variables themselves. For example in the followng code
<source lang=cpp>
// function example
#include <iostream>
using namespace std;

int addition (int a, int b)
{
int r;
r=a+b;
return (r);
}

int main ()
{
int z;
z = addition (5,3);
cout << "The result is " << z;
return 0;
}
</source>

What we did in this case was to call to function addition passing the values of <tt>x</tt> and <tt>y</tt>, i.e. <tt>5</tt> and <tt>3</tt> respectively, but not the variables <tt>x</tt> and <tt>y</tt> themselves.

[[Image:8-imgfunc1.gif]]

This way, when the function addition is called, the value of its local variables <tt>a</tt> and <tt>b</tt> become <tt>5</tt> and <tt>3</tt> respectively, but any modification to either <tt>a</tt> or <tt>b</tt> within the function addition will not have any effect in the values of <tt>x</tt> and <tt>y</tt> outside it, because variables <tt>x</tt> and <tt>y</tt> were not themselves passed to the function, but only copies of their values at the moment the function was called.

But there might be some cases where you need to manipulate from inside a function the value of an external variable. For that purpose we can use arguments passed by reference, as in the function duplicate of the following example:

{| class="codebox"
| class="code" |
// passing parameters by reference

<nowiki>#include <iostream></nowiki>
using namespace std;

void duplicate (int& a, int& b, int& c)
{
a*=2;
b*=2;
c*=2;
}

int main ()
{
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}

| class="result" |
x=2, y=6, z=14
|}

The first thing that should call your attention is that in the declaration of <tt>duplicate</tt> the type of each parameter was followed by an ampersand sign (<tt>&</tt>). This ampersand is what specifies that their corresponding arguments are to be passed ''by reference'' instead of ''by value''.

When a variable is passed by reference we are not passing a copy of its value, but we are somehow passing the variable itself to the function and any modification that we do to the local variables will have an effect in their counterpart variables passed as arguments in the call to the function.

[[Image:8-imgfunc3.gif]]

To explain it in another way, we associate <tt>a</tt>, <tt>b</tt> and <tt>c</tt> with the arguments passed on the function call (<tt>x</tt>, <tt>y</tt> and <tt>z</tt>) and any change that we do on <tt>a</tt> within the function will affect the value of <tt>x</tt> outside it. Any change that we do on <tt>b</tt> will affect <tt>y</tt>, and the same with <tt>c</tt> and <tt>z</tt>.

That is why our program's output, that shows the values stored in <tt>x</tt>, <tt>y</tt> and <tt>z</tt> after the call to <tt>duplicate</tt>, shows the values of all the three variables of <tt>main</tt> doubled.

If when declaring the following function:

{| class="snippet"
| class="code" |
void duplicate (int& a, int& b, int& c)

|}

we had declared it this way:

{| class="snippet"
| class="code" |
void duplicate (int a, int b, int c)
|}

i.e., without the ampersand signs (<tt>&</tt>), we would have not passed the variables by reference, but a copy of their values instead, and therefore, the output on screen of our program would have been the values of <tt>x</tt>, <tt>y</tt> and <tt>z</tt> without having been modified.

Passing by reference is also an effective way to allow a function to return more than one value. For example, here is a function that returns the previous and next numbers of the first parameter passed.

{| class="codebox"
| class="code" |
// more than one returning value

<nowiki>#include <iostream></nowiki>
using namespace std;

void prevnext (int x, int& prev, int& next)
{
prev = x-1;
next = x+1;
}

int main ()
{
int x=100, y, z;
prevnext (x, y, z);
cout << "Previous=" << y << ", Next=" << z;
return 0;
}

| class="result" |
Previous=99, Next=101
|}

==Passing functions as pointers==
;Note: This section can be skipped without much harm!

We can pass whole functions as arguments to other functions using pointers. See the following example.

<source lang=cpp>
#include <iostream>
using namespace std;
int oper(int one, int two, int (*myfunc)(int,int)){ // pointee of myfunc is a function
//and takes two integer arguments
// and return an integer.
return (*myfunc)(one,two); // &x - 'pointer of x is..'
// *x - 'pointee of x is..'

}

int bigger(int a, int b){
if(a>b){
return a;
}else{
return b;
}
}

int smaller(int a, int b){
if(a>b){
return b;
}else{
return a;
}
}

int main ()
{
int a=5, b=10;
cout << oper(a,b,&bigger)<<'\n';
cout << oper(a,b,&smaller)<<'\n';
}

</source>

Template:Cpptutorial Pointers - Revision history

Root: 1 revision(s)

Root: /* Passing functions as pointers */