Click here to Skip to main content
12,623,511 members (28,629 online)
Click here to Skip to main content
Add your own
alternative version

Stats

567.5K views
53 downloads
110 bookmarked
Posted

Pointer to Pointer and Reference to Pointer

, 1 Oct 2016 CPOL
Rate this:
Please Sign up or sign in to vote.
Explains the reason behind using pointer-to-pointer and reference-to-pointer to modify a pointer passed to a function.

Contents

Introduction
Why We Need Them?
Syntax of Pointer to Pointer
Syntax of Reference to Pointer
Syntax of Returning Pointer
Preference of one over the other?
Do not Mistake Pointer to Pointer arguments
Reference to Pointer type (RTTI)
Conclusion
History

Introduction

This article explains the reason behind using pointer-to-pointer and reference-to-pointer to modify a pointer passed to a function, so as to understand their usage better. For brevity, I use the terms, ptr-to-ptr and ref-to-ptr to represent them respectively. In this article, I'm not going to discuss how to use ptr-to-ptr as a 2 dimensional array or array of pointers. Please note we can use ptr-to-ptr in both C and C++ but we can use ref-to-ptr only in C++.

Why We Need Them?

When we use "pass by pointer" to pass a pointer to a function, only a copy of the pointer is passed to the function. We can say "pass by pointer" is passing a pointer by value. In most cases, this does not present a problem. But problem comes when you modify the pointer inside the function. Instead of modifying the variable, you are only modifying a copy of the pointer and the original pointer remains unmodified, that is, it still points to the old variable. The code below demonstrates this behavior.

int g_n = 42;

void example_ptr()
{
    int n = 23;
    int* pn = &n;

    std::cout << "example_ptr()" << std::endl;

    std::cout << "Before :" << *pn << std::endl; // display 23

    func_ptr(pn);

    std::cout << "After :" << *pn << std::endl; // display 23
}

void func_ptr(int* pp)
{
    pp = &g_n;
}

Syntax of Pointer to Pointer

This is how you call the function with ptr-to-ptr parameter.

int g_n = 42;

void example_ptr_to_ptr()
{
    int n = 23;
    int* pn = &n;

    std::cout << "example_ptr_to_ptr()" << std::endl;

    std::cout << "Before :" << *pn << std::endl; // display 23

    func_ptr_to_ptr(&pn);

    std::cout << "After :" << *pn << std::endl; // display 42
}

void func_ptr_to_ptr(int** pp)
{
    *pp = &g_n;
}

Syntax of Reference to Pointer

Now let us look at how you call the function with ref-to-ptr parameter

int g_n = 42;

void example_ref_to_ptr()
{
    int n = 23;
    int* pn = &n;

    std::cout << "example_ref_to_ptr()" << std::endl;

    std::cout << "Before :" << *pn << std::endl; // display 23

    func_ref_to_ptr(pn);

    std::cout << "After :" << *pn << std::endl; // display 42
}

void func_ref_to_ptr(int*& pp)
{
    pp = &g_n;
}

You may wonder whether, in the above func(), the parameter rpInt is pointer to reference. Just take my word for it that it is called ref-to-ptr and it is ref-to-ptr.

Syntax of Returning Pointer

Or you can just simply return the pointer.

int g_n = 42;

void example_ret_ptr()
{
    int n = 23;
    int* pn = &n;

    std::cout << "example_ret_ptr()" << std::endl;

    std::cout << "Before :" << *pn << std::endl; // display 23

    pn = func_ret_ptr();

    std::cout << "After :" << *pn << std::endl; // display 42
}

int* func_ret_ptr()
{
    return &g_n;
}

Preference of one over the other?

Now we have seen the syntax of ptr-to-ptr and ref-to-ptr. Are there any advantages of one over the other? I am afraid, no. The usage of one of both, for some programmers are just personal preferences. Some who use ref-to-ptr say the syntax is "cleaner" while some who use ptr-to-ptr, say ptr-to-ptr syntax makes it clearer to those reading what you are doing.

Do not Mistake Pointer to Pointer Arguments

Do not mistake every ptr-to-ptr arguments as purely ptr-to-ptr. An example would be when some write int main(int argc, char *argv[]) as int main(int argc, char **argv) where **argv is actually an array of pointers. Be sure to check out the library documentation first!

Reference to Pointer type (RTTI)

You cannot use RTTI to find out the type of ref-to-ptr. As typeid() does not support reference types.

void test(int*& rpInt)
{
  std::cout << "type of *&rpInt: " << typeid(rpInt).name() 
    << std::endl;//will show int *

}

Conclusion

You may ask if you would ever use ptr-to-ptr and ref-to-ptr in your projects and if it is necessary to know about them. Well, as developers, we use libraries and technologies developed by others. One example would be COM uses ptr-to-ptr to return an interface pointer using CoCreateInstance() and IUnknown::QueryInterface(). Up to some point in your developer career, you are definitely going to come across them. It is good to know them.

History

  • 2016/10/02 Simpler examples
  • 2009/04/29 Updated the explanations and added tracking reference to a handle in C++/CLI section.
  • 2003/09/01 First release

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Shao Voon Wong
Software Developer (Senior)
United States United States
IT Certifications

  • IT Infrastructure Library Foundational (ITIL v3)
  • Scrum Alliance Certified Scrum Master (CSM)
  • EC-Council Certified Secure Programmer (ECSP) .NET
  • EC-Council Certified Ethical Hacker (CEH)
  • EC-Council Certified Security Analyst (ECSA)
  • Certified Secure Software Lifecycle Professional (CSSLP)

You may also be interested in...

Comments and Discussions

 
PraiseWell done Pin
ITISAG13-Apr-16 14:08
memberITISAG13-Apr-16 14:08 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.161128.1 | Last Updated 2 Oct 2016
Article Copyright 2016 by Shao Voon Wong
Everything else Copyright © CodeProject, 1999-2016
Layout: fixed | fluid