Skip to content Skip to navigation


You are here: Home » Content » Indirection Operator


Recently Viewed

This feature requires Javascript to be enabled.


(What is a tag?)

These tags come from the endorsement, affiliation, and other lenses that include this content.

Indirection Operator

Module by: Kenneth Leroy Busbee. E-mail the author

Summary: An introduction to the indirection operator as used within the C++ programming language.

Note: You are viewing an old version of this document. The latest version is available here.

Indirection Operator in C++

When we pass parameters to functions we usually pass by value; that is the calling function provides several values to the called function as needed. The called function takes these values which have local scope and stores them on the stack using them as needed for whatever processing the functions accomplishes. This is the preferred method when calling user defined specific task functions. The called function passes back a single value as the return item if needed. This has the advantage of a closed communications model with everything being neatly passed in as values and any needed item returned back as a parameter.

By necessity there are two exceptions to this closed communications model:

  1. When we need more than one item of information returned by the function
  2. When a copy of an argument cannot reasonably or correctly be made (example: file stream objects).

These exceptions could be handled by parameter passing by reference instead of passing a value. Although different syntax than parameter passing when using a reference variable; using a pointer variable and the indirection operator can accomplish the same effect. The indirection operator is the asterisk or the character that we also use for multiplication. The concept of indirection is also known as dereferencing, meaning that we are not interested in the pointer but want the item to which the address is referring or referencing.

Example 1: parameter passing with pointers

// prototype
void process_values(int qty_dimes, int qty_quarters, double * ptr_value_dimes, double * ptr_value_quarters);

// variable definitions
int      dimes = 45;
int      quarters = 33;
double   value_dimes;
double   value_quarters;
double * ptr_value_dimes = &value_dimes;
double * ptr_value_quarters = &value_quarters;

// somewhere in the function main
process_values(dimes, quarters, ptr_value_dimes, ptr_value_quarters);

// definition of the function
void process_values(int qty_dimes, int qty_quarters, double * ptr_value_dimes, double * ptr_quarters);
  * ptr_value_dimes = dimes * 0.10;
  * ptr_value_quarters = quarters * 0.25;


The asterisk and must appear in both the prototype and the function definition when defining the pointer variables but it does not appear in the function call when the pointers are passed into the function.

The above example shows the basic mechanics of the indirection operator.

The use of pointers with indirection is often preferred for processing arrays. The array index operator is also known as the array method of dereferencing. The following couts are equivalent:

int ages[] = {47, 45, 18, 11, 9};

cout << ages[3];

cout << *(ages + 3);

The both say, "The name of an array is a pointer; take the pointer and calculate a new address that points to the 3rd offset by adding the correct number of bytes onto the pointer (integer data type is normally 4 bytes long – 3 offsets times 4 bytes is 12 bytes); then dereference that pointer (since this is an Rvalue context – fetch me the value that you are pointing at) and send it to the standard output device."

You should study the demonstration programs in conjunction with this module.

Demonstration Program in C++

Creating a Folder or Sub-Folder for Source Code Files

Depending on your compiler/IDE, you should decide where to download and store source code files for processing. Prudence dictates that you create these folders as needed prior to downloading source code files. A suggested sub-folder for the Bloodshed Dev-C++ 5 compiler/IDE might be named:

  • Demo_Programs

If you have not done so, please create the folder(s) and/or sub-folder(s) as appropriate.

Download the Demo Program

Download and store the following file(s) to your storage device in the appropriate folder(s). Following the methods of your compiler/IDE, compile and run the program(s). Study the source code file(s) in conjunction with other learning materials. You may need to right click on the link and select "Save Target As" in order to download the file.

Download from Connexions: Demo_Pointer_Passing.cpp

Download from Connexions: Demo_Array_ Pointer_Processing.cpp


Definition 1: indirection operator
The asterisk used for dereferencing a pointer.
Definition 2: dereferencing
The concept of using the item to which a pointer or address is pointing at.

Content actions

Download module as:

Add module to:

My Favorites (?)

'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'.

| A lens I own (?)

Definition of a lens


A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

Who can create a lens?

Any individual member, a community, or a respected organization.

What are tags? tag icon

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

| External bookmarks