Question

This is a noobie question, but I’m not sure how to pass by reference in C++. I have the following class which sets up a Node and a few functions.

class Node
{
  public:
    Node *next;
    int data;
    Node(int dat)
    {
      next = NULL;
      data = dat;
    }
    Node* getNext()
    { return next; }
    void setNext(Node *n)
    { next = n;}

    void reverse(Node *root)
    {
      Node *previous = NULL;
      while(root != NULL)
      {
        Node *next = root->getNext();
        root->setNext(previous);
        previous = root;
        root = next;
      }
      root = previous;
    }
};

Now, the purpose of my little class is to create a singularly linked list and have the ability to reverse it. And it seems to work fine, if I return the node named ‘previous’ at the end of reverse.

But look at my main function:

int main()
{
  Node *root = new Node(1);
  Node *num2 = new Node(2);
  Node *num3 = new Node(3);
  Node *num4 = new Node(4);

  root->setNext(num2);
  num2->setNext(num3);
  num3->setNext(num4);
  root->printList();
  root->reverse(root);
  root->printList();

  return 0;
}

printList() was omitted for sake of space, but it just prints a list given a node. The problem is, when root->reverse(root) is called, root doesn’t actually end up pointing to ‘previous’.

The output would be this:

1
2
3
4
  // the value of previous from the reverse function is 4
1

I really don’t understand the output. Anyone care to explain what’s happening? (Why isn’t the list reversed even though if I did something like this root = root->reverse(root) where reverse returns previous, it would) why is it that root now only points to itself? I’m new to c++ and appreciate your help!

Answer 1

C++ has support for reference semantics. Therefore, for a given function:

void foo(Bar& bar);

To pass by reference you do:

int main() {
  Bar whatsit;

  foo(whatsit);

  return 0;
}

That’s it!

This is commonly confused with passing a pointer, where for a function such as:

void foo(Bar* bar);

You would do:

int main() {
  Bar whatisit;

  foo(&whatsit);

  return 0;
}

The difference is mostly a matter of semantics:
– A reference is always valid. There is no reason to check for a NULL pointer.
– A pointer could be NULL, and as such, should be checked.

It is, however, possible for a reference to refer to a NULL pointer, however, if the programmer decides to be evil and abuse reference semantics, but the principle remains.