c++ pass by reference?

/*
    This program demonstrates a few routines for processing binary
    sort trees.  It uses a binary sort tree of strings.  The user
    types in strings.  The user's string is converted to lower case, and -- 
    if it is not already in the tree -- it is inserted into the tree.
    Then the number of nodes in the tree and a list of items in the tree
    are output.  The program ends when the user enters an empty string.
*/

#include <iostream>
#include <string>
using namespace std;

class TreeNode {
   // An object of type TreeNode represents one node
   // in a binary tree of strings.
   public:
      // Constructor.  Make a node containing str.
      TreeNode(string str) : item(str), left(NULL), right(NULL) {}

      string item;      // The data in this node.
      TreeNode *left;    // Pointer to left subtree.
      TreeNode *right;   // Pointer to right subtree.
};

typedef TreeNode* TreeNodePtr;

void treeInsert(TreeNodePtr& root, string newItem);
// Add the item to the binary sort tree to which the parameter
// "root" refers.  Note that root is passed by reference since
// its value can change in the case where the tree is empty.

bool treeContains( TreeNodePtr root, string item );
// Return true if item is one of the items in the binary
// sort tree to which root points.   Return false if not.

void treeList(TreeNodePtr node);
// Print the items in the tree in postorder, one item
// to a line.  Since the tree is a sort tree, the output
// will be in increasing order.

int countNodes(TreeNodePtr node);
// Count the nodes in the binary tree to which node 
// points.  Return the answer.

int main() {

   TreeNodePtr root;// Pointer to the root node in a binary tree.  This
                    // tree is used in this program as a binary sort tree.
                    // The tree is not allowed to contain duplicate
                    // items.  When the tree is empty, root is null.

   root = NULL;     // Start with an empty tree.

   cout << "This programs stores strings that you enter in a binary sort\n";
   cout << "tree.  After each items is inserted, the contents of the tree\n";
   cout << "are displayed.  The number of nodes in the tree is also output.\n";
   cout << "    Any string you enter will be converted to lower case.\n";
   cout << "Duplicate entries are ignored.\n";

   while (true) {
       // Get one string from the user, insert it into the tree,
       // and print some information about the tree.  Exit if the
       // user enters an empty string.  Note that all strings are
       // converted to lower case.
       cout << ("\n\nEnter a string to be inserted, or press return to end.\n");
       string item;  // The user's input.
       if (cin.peek() == '\n')
          break;
       cin >> item; 
       cin.ignore(10000,'\n'); // just in case a space and other words typed
       if (treeContains(root,item)) {
          // Don't insert a second copy of an item that is already
          // in the tree.
          cout << "\nThat item is already in the tree.\n";
       }
       else {
          treeInsert(root,item);  // Add user's string to the tree.
          cout << "\nThe tree contains " << countNodes(root) << " items.\n";
          cout << "\nContents of tree:\n\n";
          treeList(root);
       }
   }  // end while

   cout << "\n\nExiting program.\n\n";

}  // end main()

void treeInsert(TreeNodePtr& root, string newItem) {
   // Add the item to the binary sort tree to which the parameter
   // "root" refers.  Note that root is passed by reference since
   // its value can change in the case where the tree is empty.
   if ( root == NULL ) {
      // The tree is empty.  Set root to point to a new node containing
      // the new item.  This becomes the only node in the tree.
      root = new TreeNode( newItem );
      return;
   }
   else if ( newItem < root->item ) {
      treeInsert( root->left, newItem );
   }
   else {
      treeInsert( root->right, newItem );
   }
}  // end treeInsert()

bool treeContains( TreeNodePtr root, string item ) {
   // Return true if item is one of the items in the binary
   // sort tree to which root points.   Return false if not.
   if ( root == NULL ) {
         // Tree is empty, so it certainly doesn't contain item.
      return false;
   }
   else if ( item == root->item ) {
      // Yes, the item has been found in the root node.
      return true;
   }
   else if ( item < root->item ) {
      // If the item occurs, it must be in the left subtree.
      return treeContains( root->left, item );
   }
   else {
      // If the item occurs, it must be in the right subtree.
      return treeContains( root->right, item );
   }
}  // end treeContains()

void treeList(TreeNodePtr node) {
   // Print the items in the tree in inorder, one item
   // to a line.  Since the tree is a sort tree, the output
   //开发者_Go百科 will be in increasing order.
   if ( node != NULL ) {
       treeList(node->left);           // Print items in left subtree.
       cout << "  " << node->item << endl;  // Print item in the node.
       treeList(node->right);          // Print items in the right subtree.
   }
} // end treeList()

int countNodes(TreeNodePtr node) {
   // Count the nodes in the binary tree to which node 
   // points.  Return the answer.
   if ( node == NULL ) {
           // Tree is empty, so it contains no nodes.
      return 0;
   }
   else {
      // Add up the root node and the nodes in its two subtrees.
      int leftCount = countNodes( node->left );
      int rightCount = countNodes( node->right );
      return  1 + leftCount + rightCount;  
   }
} // end countNodes()

One thing not understand, why this function " void treeInsert(TreeNodePtr& root, string newItem);" has "&" mark after TreeNodePtr? others not...confused!

Thank you for anyone's help!

The root pointer is passed by reference since its value can change in the case where the tree is empty.

Cheers & hth.,

All the std::strings should also be passed by const reference. This way the whole class is not placed on the stack.