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

Incrementing a Pointer - 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

An important reason for declaring a variable pointer so it points to the same address as the array name is so the variable pointer can be incremented, unlike the array name which cannot be incremented because it is a constant pointer. The fol-lowing program increments the variable pointer to access each succeeding element of the array:


Figure 11-2.  Variable and constant pointers used to access array elements

#include <iostream>> using namespace std; const int MAX = 3;

int main ()
{
  int testScore[MAX] = {4, 7, 1};
  int* iPtr = testScore;
  for (int i = 0; i < MAX; i++, iPtr++)
  {
    cout << "The address of index " << i << " of the array is "<< iPtr << endl;
    cout << "The value at index " << i << " of the array is "<< *iPtr << endl;
  }
  return 0;
}

Incrementing an integer variable increases its value by 1. However, incrementing a pointer variable increases its value by the number of bytes of its data type. This is an example of pointer arithmetic. When you run this program, the first address outputted is 0012FECC, the second 0012FED0, and the third 0012FED4. These hexadecimal addresses are 4 bytes apart because, on the compiler and operating system used by me to run this program, the integer data type takes 4 bytes.

For this reason, as shown in Figure 11-3, iPtr + 1 is not the base address plus 1, but instead is thebaseaddress+4. Thesameistrueof testScore + 1. Consequently, the value at the second element of the array can be expressed one of four ways:

  • testScore[1];
  • *(testScore + 1);
  • iPtr[1];
  • *(iPtr + 1);

 

Comparing Addresses

Addresses can be compared like any other value. The following program modifies the previous one by incrementing the variable pointer so long as the address to which it points is either less than or equal to the address of the last element of the array, which is &testScore[MAX - 1]:

#include <iostream>> using namespace std; const int MAX = 3;
int main ()
{
  int testScore[MAX] = {4, 7, 1};
  int* iPtr = testScore;
  int i = 0;
  while (iPtr <= &testScore[MAX - 1])
  {
    cout << "The address of index " << i << " of the array  is "<< iPtr << endl;
    cout << "The value at index " << i << " of the array is "<< *iPtr << endl;
    iPtr++;
    i++;
  }
  return 0;
}

As Figures 11-2 and 11-3 depict, the comparison to &testScore[MAX-1] instead could have been made to testScore + MAX – 1.

Decrementing a Pointer

The same considerations apply to decrementing a pointer, which decreases its value by the number of bytes of its data type. Decrementing a pointer can be used to step “backwards” through an array. 

#include <iostream>> using namespace std; const int MAX = 3;

int main ()
{
  int testScore[MAX] = {4, 7, 1};
  int* iPtr = &testScore[MAX - 1];
  int i = MAX - 1; while (iPtr >= &testScore[0])
  {
    cout << "The address of index " << i << " of the array is "<< iPtr << endl;
    cout << "The value at index " << i
<< " of the array is "<< *iPtr << endl;
    iPtr--;
    i--;
  }
  return 0;
}

The output is therefore

The address of index 2 of the array is 0012FED4
The value at index 2 of the array is 1
The address of index 1 of the array is 0012FED0
The value at index 1 of the array is 7
The address of index 0 of the array is 0012FECC
The value at index 0 of the array is 4

The key statement is

int* iPtr = &testScore[MAX - 1];

This statement has the variable pointer point to the last address in the array. That address then is decremented in the loop so that the pointer variable points to the preceding address in the array. The loop continues so long as the address pointed to by the pointer variable is not before the base address of the array.

As discussed previously, the pointer variable also could have been initialized as follows:

int* iPtr = testScore + MAX - 1;

Pointers as Function Arguments

Pointers may be passed as function arguments. Pointer notation usually is used to note that an argument is a pointer. However, if the pointer argument is the name of an array, subscript notation alternatively may be used. 



 
 
>>> 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: