TreeNode:

// forward declaration of class Tree
template<typename NODETYPE> class Tree;

// TreeNode class-template definition
template<typename NODETYPE>
class TreeNode
{
	 friend class Tree<NODETYPE>;  //friend class of Tree cause the private values

  public:
     TreeNode(const NODETYPE &d) // constructor
     {
        leftPtr = NULL; // pointer to left subtree
		data = d;  // tree node data
		rightPtr = NULL; // pointer to right substree
     }

     NODETYPE getData() const  // return copy of node's data
     { return data; } 

  private:
     TreeNode<NODETYPE> *leftPtr; // pointer to left subtree
	 TreeNode<NODETYPE> *rightPtr; // pointer to right subtree
     NODETYPE data;

  }; // end class TreeNode

Tree:

#include "Treenode.h"

// Tree class-template definition
template<typename NODETYPE>
class Tree
{
   public:
      Tree(); // constructor
      void insertNode(const NODETYPE &);
   private:
      TreeNode<NODETYPE> *rootPtr;

      // utility functions                                               
      void insertNodeHelper(TreeNode<NODETYPE> **, const NODETYPE &);
NODETYPE &value);

}; 

   template<typename NODETYPE>    // constructor
   Tree<NODETYPE>::Tree()
   {
      rootPtr = NULL; // indicate tree is initially empty
   }

   template<typename NODETYPE>    // insert node in Tree
   void Tree<NODETYPE>::insertNode( const NODETYPE &value )
   {
      insertNodeHelper(&rootPtr, value);
   }

   // utility function called by insertNode; receives a pointer
   // to a pointer so that the function can modify pointer's value
   template<typename NODETYPE>
   void Tree<NODETYPE>::insertNodeHelper(TreeNode<NODETYPE> **ptr, const NODETYPE &value)
   {
      // subtree is empty; create new TreeNode containing value
      if ( *ptr == NULL )
         *ptr = new TreeNode<NODETYPE>(value);
      else // subtree is not empty
      {
         // data to insert is less than data in current node
         if ( value < (*ptr)->data )
            insertNodeHelper( &((*ptr)->leftPtr), value );
         else
         {
            // data to insert is greater than data in current node
            if ( value > (*ptr)->data )
               insertNodeHelper( &((*ptr)->rightPtr), value );
            else // duplicate data value ignored
               cout << value << " dup" << endl;
         }
      } 
   }

was ich nicht verstehe, ist diese Pointer-to-Pointer arithmetik!
wenn ich versuche die methoden zu ändern, schlägt der compiler fehl!

class Tree
{
   public:
      Tree(); // constructor
      void insertNode(const NODETYPE &);
   private:
      TreeNode<NODETYPE> *rootPtr;

      // utility functions                                               
      void insertNodeHelper(TreeNode<NODETYPE> *, const NODETYPE &);
NODETYPE &value);

}; 

   template<typename NODETYPE>    // constructor
   Tree<NODETYPE>::Tree()
   {
      rootPtr = NULL; // indicate tree is initially empty
   }

   template<typename NODETYPE>    // insert node in Tree
   void Tree<NODETYPE>::insertNode( const NODETYPE &value )
   {
      insertNodeHelper(rootPtr, value);
   }

   // utility function called by insertNode; receives a pointer
   // to a pointer so that the function can modify pointer's value
   template<typename NODETYPE>
   void Tree<NODETYPE>::insertNodeHelper(TreeNode<NODETYPE> *ptr, const NODETYPE &value)
   {
      // subtree is empty; create new TreeNode containing value
      if ( ptr == NULL )
         ptr = new TreeNode<NODETYPE>(value);
      else // subtree is not empty
      {
         // data to insert is less than data in current node
         if ( value < ptr->data )
            insertNodeHelper( ptr->leftPtr, value );
         else
         {
            // data to insert is greater than data in current node
            if ( value > ptr->data )
               insertNodeHelper( ptr->rightPtr, value );
            else // duplicate data value ignored
               cout << value << " dup" << endl;
         }
      } 
   }

so möchte ich das haben..ohne pointertoponiter..aber wie mache ich das???

void Tree<NODETYPE>::insertNodeHelper(TreeNode<NODETYPE>& *ptr, const NODETYPE &value)

error C2528: '<unbekannt>' : Zeiger auf Verweis ungueltig

so rum

versteh den sinn trotzdem nicht!

void test(int* x)
{
  x = new int;
  *x = 10;
}

int* a = 0;
test(a);
cout << *a << endl; // Undefiniert, a ist immernoch 0, und 0 darf nicht dereferenziert werden

Hier wird ein Zeiger by-value übergeben. Das heisst, die Adresse, die in a steht, wird an die Funktion test übergeben und in der Variablen x abgelegt. Wenn Du x änderst, änderst Du also nur die Kopie der Adresse. Das, worauf ein Zeiger zeigt, kann man manipulieren (und um das Gewünschte zu erreichen, hat man in C in diesem Fall einen Doppelzeiger übergeben müssen).

void test(int*& x)
{
  x = new int;
  *x = 10;
}

int* a = 0;
test(a);
cout << *a << endl; // Ausgabe: 10

In C++ gibt es jedoch die Möglichkeit der Referenz, wo nicht nur ein Wert by-value übergeben wird, sondern tatsächlich die Variable selbst. Das & hier ist nicht der Adressoperator, sondern der Referenzqualifizierer. Hier ist x die Variable a aus dem Hauptprogramm, nicht nur eine Kopie. Eine Änderung in x ändert also automatisch auch a.

hilfe!

OO ftpopo!
*paranoia!*