Home arrow Practices arrow Page 5 - What`s the Address? Pointers

Passing an Array Using Pointer Notation - Practices

The name "pointer" describes the job of the item; a pointer "points" to another variable or constant. Some tasks in C++ are easier to do with pointers; others would be utterly impossible without pointers. This article discusses how to create and work with pointers in C++. It is taken from chapter 11 of the book C++ Demystified, written by Jeff Kent (McGraw-Hill/Osborne, 2004; ISBN: 0072253703).

TABLE OF CONTENTS:
  1. What`s the Address? Pointers
  2. Assigning a Pointer the Address of a Variable or Constant
  3. The Array Name as a Constant Pointer
  4. Incrementing a Pointer
  5. Passing an Array Using Pointer Notation
  6. Dynamic Memory Allocation
  7. Returning Pointers from Function s
  8. Summary
By: McGraw-Hill/Osborne
Rating: starstarstarstarstar / 16
September 01, 2005

print this article
SEARCH DEV SHED

TOOLS YOU CAN USE

advertisement

In Chapter 10, we employed the following program that used one function to assign values to the array and another function to display values from the array, rather than doing all that work in the main function. 

#include <iostream>
using namespace std;
void assignValues(int[], int);
void displayValues(int[], int);
const int MAX = 3;

int main ()
{
  int testScore[MAX];
  assignValues(testScore, MAX);
  displayValues(testScore, MAX);
  return 0;
  }

  void assignValues(int tests[], int num)
  {
    for (int i = 0; i < num; i++)
      {
cout << "Enter test score #" << i + 1 << ": "; cin >> tests[i];
      }
  }

  void displayValues(int scores[], int elems)
 
{
    for (int i = 0; i < elems; i++)
     
{
        cout << "Test score #" << i + 1 << ": " << scores[i] << endl;
  }
}

As discussed in Chapter 10, the two functions, assignValues and displayValues, passed their first argument, the array, by address. An argument passed by address can be changed in the calling function (here main) by the called function (here assignValues) just as if the argument had been passed by reference. Thus, the assignValues function changed the value of the testScore array in main by assigning values to the elements of that array.

The function prototypes and headers of the assignValues and displayValues functions used a subscript [] to indicate that an array is being passed. However, you can also use pointer notationófor instance, asterisk * instead of a subscript []óas the following example demonstrates:

#include <iostream>
using namespace std;
void assignValues(int*, int);
void displayValues(int*, int);
const int MAX = 3;

int main ()
{
  int testScore[MAX]; assignValues(testScore, MAX);
  displayValues(testScore, MAX);
  return 0;
}

void assignValues(int* tests, int num)
{
  for (int i = 0; i < num; i++)
  { 
    cout << "Enter test score #" << i + 1 << ": ";
    cin >> tests[i];
  }
}

void displayValues(int* scores, int elems)
{
  for (int i = 0; i < elems; i++)
  {
    cout << "Test score #" << i + 1 << ": " << scores[i] << endl;
  }
}

The following comparison of the prototypes of the assignValues function using subscript and pointer notation, respectively, shows that the only difference is whether a subscript [] or an asterisk * is used to denote that the argument is an array:

void assignValues(int[], int);
void assignValues(int*, int);

Similarly, the following comparison of the function headers of the assignValues function using subscript and pointer notation, respectively, shows that the only difference is whether a subscript [] or an asterisk * is used to denote that the argument is an array. This time, however, the asterisk precedes the variable name, whereas the subscript follows the variable name.

void assignValues(int tests[], int num)
void assignValues(int* tests, int num)

Whether you use subscript or pointer notation to pass an array really is a matter of preference. There is no programming advantage one way or the other. However, the next section discusses a situation in which subscript notation is not an option, so pointer notation is the only choice.

Passing a Single Variable Using Pointer Notation

Passing an array name by address is relatively simple because the value of the array name is an address. However, you may often want to pass a single variable by address. By single variable I donít mean a variable that is unmarried, but instead, for example, an int as opposed to an int array. 

With a single variable, subscript notation is not an option. Subscripts make sense only with an array. Rather, you need to use pointer notation to pass a single variable by address.

Passing an argument by reference or by address both enable the passed argument to be changed in the calling function by the called functionóonly the syntax is different. For comparison, letís start with the following program from Chapter 9 that passes the variable to be doubled by reference:

#include <iostream <iostream>>
using namespace std;
void doubleIt(int&);

int main ()
{
int num;
  cout << "Enter number: ";
  cin >> num;
  doubleIt(num);
  cout << "The number doubled in main is " << num << endl;
  return 0;
}

void doubleIt (int& x)
{
  cout << "The number to be doubled is " << x << endl;
  x*=2;
  cout << "The number doubled in doubleIt is " << x << endl;
}

Here is some sample input and output:

Enter number: 3
The number to be doubled is 3
The number doubled in doubleIt is 6
The number doubled in main is 6

Letís now modify this program so it passes the variable to be doubled by address instead of by reference:

#include <iostream>
using namespace std;
void doubleIt(int*);

int main ()
{
  int num;
  cout << "Enter number: ";
  cin >> num;
  doubleIt(&num);
  cout << "The number doubled in main is " << num << endl;
  return 0;
}

void doubleIt (int* x)
  {
  cout << "The number to be doubled is " << *x << endl;
  *x *= 2;
  cout << "The number doubled in doubleIt is " << *x << endl;
}

There are four syntax differences between these two programs.

1. In the function prototype, you use an ampersand (&) for passing by reference but an asterisk (*) for passing by address:

void doubleIt(int&); // by reference
void doubleIt(int*); // by address

2. Similarly, in the function header, you use an ampersand (&) for passing by reference but an asterisk (*) for passing by address:

void doubleIt (int& x) // by reference
void doubleIt (int* x) // by address

3. When you call the function, you donít need the address operator (&) for passing by reference, but you do need one for passing by address since you are supposed to be passing by the address of x.:

doubleIt(num); // by reference
doubleIt(&num); // by address

4. In the body of the called function, you donít need to dereference the argument when you pass it by reference, but you do need to when you pass by address since x, being passed by address, is not a value but is instead a pointer:

// by reference -no dereference

  cout << "The number to be doubled is " << x << endl;
  x*=2;
  cout << "The number doubled in doubleIt is " << x << endl;
}
// by address -need to dereference
{
  cout << "The number to be doubled is " << *x << endl;
  *x *= 2;
  cout << "The number doubled in doubleIt is " << *x << endl;
}

You may legitimately be wondering why, with a single variable argument, I would want to pass it by address when the syntax for passing it by reference seems easier. The pat answer I give my students is that there are certain sadistic computer science teachers (Iím not mentioning any names here) who insist their students pass by address to make them suffer. All kidding aside though, there are actually certain library functions that do use pass by address. Additionally, when using dynamic memory allocation and returning pointers from functions (to be covered in the following sections), passing by address may be the only option.



 
 
>>> More Practices Articles          >>> More By McGraw-Hill/Osborne
 

blog comments powered by Disqus
escort Bursa Bursa escort Antalya eskort
   

PRACTICES ARTICLES

- Calculating Development Project Costs
- More Techniques for Finding Things
- Finding Things
- Finishing the System`s Outlines
- The System in So Many Words
- Basic Data Types and Calculations
- What`s the Address? Pointers
- Design with ArgoUML
- Pragmatic Guidelines: Diagrams That Work
- Five-Step UML: OOAD for Short Attention Span...
- Five-Step UML: OOAD for Short Attention Span...
- Introducing UML: Object-Oriented Analysis an...
- Class and Object Diagrams
- Class Relationships
- Classes

Developer Shed Affiliates

 


Dev Shed Tutorial Topics: