when i need pass by pointer (and not by reference)

Question

Can you give me an example when I can't pass argument by reference and I need to use pointer. I've found an example, but I'm not sure.

Suppose you have a class D derived from the base class B. You need pointer if you want do so:

void function(B* b){...}
int main{
  D* d;
  function(d);
}

Answer 1

The single time where you can not use a reference and must use a pointer is if you allow the concept of "no argument" by passing a null pointer.

However, you might want to use pointers as arguments when you are actually storing a pointer to whatever was passed. Most C++ developpers will notice that you aren't using a reference and pay special attention to what your documentation says.

Answer 2

the only reason is if you need to pass null. I.e you want to call the function saying 'I haven't got one of those'

Answer 3

If there is a coding guideline (like Google's) that says to use pointer arguments, then that's what you do.

Otherwise, only declare your own function with pointer formal argument when

• a nullpointer is a valid & meaningful actual argument, or

• the actual argument is most naturally pointer already, or

• you're going to store that pointer somewhere.

Possibly more cases, but I think you get the drift: when you have a choice (no coding guideline saying otherwise), prefer references.

Cheers & hth.,

Answer 4

If you want to allow the lack of an object, you need to use pointers:

// This allows DoSomething to receive pointers to NULL, which cannot
// be done with references
void DoSomething(Something *pSomething)
{
  if (pSomething)
  {
    ...
  }
}

int main()
{
  Something *pSomething=NULL;

  DoSomething(pSomething);
}

Answer 5

http://www.daniweb.com/forums/thread216353.html

Singly linked lists example were pointers and pointer of pointers are used as function parameters.

Answer 6

I think that if you want to pass a function, you have to pass it by pointer. I don't see how you can pass the function by reference.

For example, take the following function:

#include <iostream>
#include "math.h"

void myfun (double value, size_t nofloops, double (*function)(double))
   {
   std::cout << value << std::endl;
   for (size_t i=0;i<nofloops;++i)
      {
      value = function(value);
      std::cout << value << std::endl;
      }
   std::cout << "------------------" << std::endl;
   }

void main()
   {
   myfun(100,10,sin);
   myfun(100,10,cos);
   myfun(100,10,sqrt);
   }

The function in this small utility executes the given function a number of times, taking the result as input in the next iteration. I can't see how you can pass the function by reference.

Answer 7

In C++ you can pass arguments by value, by reference or by pointer. But you should prefer to pass objects by reference, taking into account that it is a value semantic. Remember that depending on if you create an object by declaring a variable of that type, C++ allocates the object in the stack, but if you declare a pointer to that object you might initialize it, with the new operator (to really create the object instance in the heap). Also do not forget to use the delete operator for every object you created on the heap.

class B { B(){...} }
class D : B { D(): B{...}  } /*declares a class D, that derives from class B */
void f(B *b) {...} /* pointer semantics: the pointer b points to any object of the type B   */
void g(B &b) {...}  /* value semantics, because the type, the object is received by reference */
int main
{
    D d1;    /* object d1 is declared and created on the stack */
    D* d2;   /* pointer d2, to object of type D is declared */

    d2 = new D(); /* d2 allocates an object created in the heap (this calls the object constructor)*/

    f(&d1); /* calls the function f, pasing the reference of the object d1*/
    g(d2)   /* calls the function g, using value semantics */

    delete d2 /*de-allocates memory created on the heap (this calls the objects destructor)*/
}

The Scotts Meyers book is one of the most comprehensive guide regarding with C++.

Answer 8

Another case: if the thing you're passing is the last argument before varargs:

void fn1(A &a, ...); // Uh oh
void fn2(A *a, ...); // Good

I don't know if this is required by the standard, or is just a bug in the implementation of the C++ compiler I use.

Answer 9

Typically, you use pointers for one of two things:

• Reassignability - you can't rebind a reference.
• Null pointers - there's no such thing as a null reference.

If your intended use case does not need either of those two properties, use a reference. Else, use a pointer.