C++의 템플릿 클래스

Question

안녕하세요 아래 코드에서 함수를 선언 할 때마다 오류 메시지 error: expected initializer before '<' token이 표시됩니다. 나는 C++의 템플릿에 익숙하지 않아서이 에러가 정말 나를 던지고있다. 이미 typename 키워드를 사용하려고했지만 작동하지 않았습니다. 어떤 도움이라도 좋을 것입니다.

BinarySearchTree.h

 #ifndef BINARY_SEARCH_TREE_H_ 
     #define BINARY_SEARCH_TREE_H_ 

     #include "dsexceptions.h" 
     #include <iostream.h>  // For NULL 

      // Binary node and forward declaration because g++ does 
      // not understand nested classes. 
     template <class Comparable> 
     class BinarySearchTree; 

     template <class Comparable> 
     class BinaryNode 
     { 
      Comparable element; 
      BinaryNode *left; 
      BinaryNode *right; 

      BinaryNode(const Comparable & theElement, BinaryNode *lt, BinaryNode *rt) 
       : element(theElement), left(lt), right(rt) { } 
      friend class BinarySearchTree<Comparable>; 
     }; 


     // BinarySearchTree class 
     // 
     // CONSTRUCTION: with ITEM_NOT_FOUND object used to signal failed finds 
     // 
     // ******************PUBLIC OPERATIONS********************* 
     // void insert(x)  --> Insert x 
     // void remove(x)  --> Remove x 
     // Comparable find(x) --> Return item that matches x 
     // Comparable findMin() --> Return smallest item 
     // Comparable findMax() --> Return largest item 
     // boolean isEmpty()  --> Return true if empty; else false 
     // void makeEmpty()  --> Remove all items 
     // void printTree()  --> Print tree in sorted order 

     template <class Comparable> 
     class BinarySearchTree 
     { 
      public: 
      explicit BinarySearchTree(const Comparable & notFound); 
      BinarySearchTree(const BinarySearchTree & rhs); 
      ~BinarySearchTree(); 

      const Comparable & findMin() const; 
      const Comparable & findMax() const; 
      const Comparable & find(const Comparable & x) const; 
      bool isEmpty() const; 
      void printTree() const; 

      void makeEmpty(); 
      void insert(const Comparable & x); 
      void remove(const Comparable & x); 

      const BinarySearchTree & operator=(const BinarySearchTree & rhs); 

      private: 
      BinaryNode<Comparable> *root; 
      const Comparable ITEM_NOT_FOUND; 

      const Comparable & elementAt(BinaryNode<Comparable> *t) const; 

      void insert(const Comparable & x, BinaryNode<Comparable> * & t) const; 
      void remove(const Comparable & x, BinaryNode<Comparable> * & t) const; 
      BinaryNode<Comparable> * findMin(BinaryNode<Comparable> *t) const; 
      BinaryNode<Comparable> * findMax(BinaryNode<Comparable> *t) const; 
      BinaryNode<Comparable> * find(const Comparable & x, BinaryNode<Comparable> *t) const; 
      void makeEmpty(BinaryNode<Comparable> * & t) const; 
      void printTree(BinaryNode<Comparable> *t) const; 
      BinaryNode<Comparable> * clone(BinaryNode<Comparable> *t) const; 
     }; 

     #include "BinarySearchTree.cpp" 
     #endif 

BinarySearchTree.cpp

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

     /** 
     * Implements an unbalanced binary search tree. 
     * Note that all "matching" is based on the < method. 
     */ 

     /** 
     * Construct the tree. 
     */ 
     template <class Comparable> 
     BinarySearchTree<Comparable>::BinarySearchTree(const Comparable & notFound) : 
      root(NULL), ITEM_NOT_FOUND(notFound) 
     { 
     } 


     /** 
     * Copy constructor. 
     */ 
     template <class Comparable> 
     BinarySearchTree<Comparable>:: 
     BinarySearchTree(const BinarySearchTree<Comparable> & rhs) : 
      root(NULL), ITEM_NOT_FOUND(rhs.ITEM_NOT_FOUND) 
     { 
      *this = rhs; 
     } 

     /** 
     * Destructor for the tree. 
     */ 
     template <class Comparable> 
     BinarySearchTree<Comparable>::~BinarySearchTree() 
     { 
      makeEmpty(); 
     } 

     /** 
     * Insert x into the tree; duplicates are ignored. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>::insert(const Comparable & x) 
     { 
      insert(x, root); 
     } 

     /** 
     * Remove x from the tree. Nothing is done if x is not found. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>::remove(const Comparable & x) 
     { 
      remove(x, root); 
     } 


     /** 
     * Find the smallest item in the tree. 
     * Return smallest item or ITEM_NOT_FOUND if empty. 
     */ 
     template <class Comparable> 
     const Comparable & BinarySearchTree<Comparable>::findMin() const 
     { 
      return elementAt(findMin(root)); 
     } 

     /** 
     * Find the largest item in the tree. 
     * Return the largest item of ITEM_NOT_FOUND if empty. 
     */ 
     template <class Comparable> 
     const Comparable & BinarySearchTree<Comparable>::findMax() const 
     { 
      return elementAt(findMax(root)); 
     } 

     /** 
     * Find item x in the tree. 
     * Return the matching item or ITEM_NOT_FOUND if not found. 
     */ 
     template <class Comparable> 
     const Comparable & BinarySearchTree<Comparable>:: 
           find(const Comparable & x) const 
     { 
      return elementAt(find(x, root)); 
     } 

     /** 
     * Make the tree logically empty. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>::makeEmpty() 
     { 
      makeEmpty(root); 
     } 

     /** 
     * Test if the tree is logically empty. 
     * Return true if empty, false otherwise. 
     */ 
     template <class Comparable> 
     bool BinarySearchTree<Comparable>::isEmpty() const 
     { 
      return root == NULL; 
     } 

     /** 
     * Print the tree contents in sorted order. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>::printTree() const 
     { 
      if(isEmpty()) 
       cout << "Empty tree" << endl; 
      else 
       printTree(root); 
     } 

     /** 
     * Deep copy. 
     */ 
     template <class Comparable> 
     const BinarySearchTree<Comparable> & 
     BinarySearchTree<Comparable>:: 
     operator=(const BinarySearchTree<Comparable> & rhs) 
     { 
      if(this != &rhs) 
      { 
       makeEmpty(); 
       root = clone(rhs.root); 
      } 
      return *this; 
     } 

     /** 
     * Internal method to get element field in node t. 
     * Return the element field or ITEM_NOT_FOUND if t is NULL. 
     */ 
     template <class Comparable> 
     const Comparable & BinarySearchTree<Comparable>:: 
     elementAt(BinaryNode<Comparable> *t) const 
     { 
      if(t == NULL) 
       return ITEM_NOT_FOUND; 
      else 
       return t->element; 
     } 

     /** 
     * Internal method to insert into a subtree. 
     * x is the item to insert. 
     * t is the node that roots the tree. 
     * Set the new root. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>:: 
     insert(const Comparable & x, BinaryNode<Comparable> * & t) const 
     { 
      if(t == NULL) 
       t = new BinaryNode<Comparable>(x, NULL, NULL); 
      else if(x < t->element) 
       insert(x, t->left); 
      else if(t->element < x) 
       insert(x, t->right); 
      else 
       ; // Duplicate; do nothing 
     } 

     /** 
     * Internal method to remove from a subtree. 
     * x is the item to remove. 
     * t is the node that roots the tree. 
     * Set the new root. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>:: 
     remove(const Comparable & x, BinaryNode<Comparable> * & t) const 
     { 
      if(t == NULL) 
       return; // Item not found; do nothing 
      if(x < t->element) 
       remove(x, t->left); 
      else if(t->element < x) 
       remove(x, t->right); 
      else if(t->left != NULL && t->right != NULL) // Two children 
      { 
       t->element = findMin(t->right)->element; 
       remove(t->element, t->right); 
      } 
      else 
      { 
       BinaryNode<Comparable> *oldNode = t; 
       t = (t->left != NULL) ? t->left : t->right; 
       delete oldNode; 
      } 
     } 

     /** 
     * Internal method to find the smallest item in a subtree t. 
     * Return node containing the smallest item. 
     */ 
     template <class Comparable> 
     BinaryNode<Comparable> * 
     BinarySearchTree<Comparable>::findMin(BinaryNode<Comparable> *t) const 
     { 
      if(t == NULL) 
       return NULL; 
      if(t->left == NULL) 
       return t; 
      return findMin(t->left); 
     } 

     /** 
     * Internal method to find the largest item in a subtree t. 
     * Return node containing the largest item. 
     */ 
     template <class Comparable> 
     BinaryNode<Comparable> * 
     BinarySearchTree<Comparable>::findMax(BinaryNode<Comparable> *t) const 
     { 
      if(t != NULL) 
       while(t->right != NULL) 
        t = t->right; 
      return t; 
     } 

     /** 
     * Internal method to find an item in a subtree. 
     * x is item to search for. 
     * t is the node that roots the tree. 
     * Return node containing the matched item. 
     */ 
     template <class Comparable> 
     BinaryNode<Comparable> * 
     BinarySearchTree<Comparable>:: 
     find(const Comparable & x, BinaryNode<Comparable> *t) const 
     { 
      if(t == NULL) 
       return NULL; 
      else if(x < t->element) 
       return find(x, t->left); 
      else if(t->element < x) 
       return find(x, t->right); 
      else 
       return t; // Match 
     } 
/****** NONRECURSIVE VERSION************************* 
     template <class Comparable> 
     BinaryNode<Comparable> * 
     BinarySearchTree<Comparable>:: 
     find(const Comparable & x, BinaryNode<Comparable> *t) const 
     { 
      while(t != NULL) 
       if(x < t->element) 
        t = t->left; 
       else if(t->element < x) 
        t = t->right; 
       else 
        return t; // Match 

      return NULL; // No match 
     } 
*****************************************************/ 

     /** 
     * Internal method to make subtree empty. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>:: 
     makeEmpty(BinaryNode<Comparable> * & t) const 
     { 
      if(t != NULL) 
      { 
       makeEmpty(t->left); 
       makeEmpty(t->right); 
       delete t; 
      } 
      t = NULL; 
     } 

     /** 
     * Internal method to print a subtree rooted at t in sorted order. 
     */ 
     template <class Comparable> 
     void BinarySearchTree<Comparable>::printTree(BinaryNode<Comparable> *t) const 
     { 
      if(t != NULL) 
      { 
       printTree(t->left); 
       cout << t->element << endl; 
       printTree(t->right); 
      } 
     } 

     /** 
     * Internal method to clone subtree. 
     */ 
     template <class Comparable> 
     BinaryNode<Comparable> * 
     BinarySearchTree<Comparable>::clone(BinaryNode<Comparable> * t) const 
     { 
      if(t == NULL) 
       return NULL; 
      else 
       return new BinaryNode<Comparable>(t->element, clone(t->left), clone(t->right)); 
     } 

Answer 1

당신이 당신의 .H 파일에 함수를 정의 할 필요가 없습니다 클래스를 템플릿. .cpp 파일에서 이들을 정의 할 수도 없습니다. 내가 항상 해왔 던 방법은 일반적으로하는 것처럼 .h 파일에 템플릿 화 된 클래스를 정의하는 것입니다. 그리고 함수 정의를 .hpp 파일에 작성합니다.

.H 파일

은 다음과 같이 기록 될 것입니다 :

#ifndef MYCLASS_H 
#define MYCLASS_H 

template<typename T> class MyClass 
{ 
public: 
    int MyFunction(); 
} 
#include "MyClass.hpp" 
#endif 

당신이 당신의 .H 파일에 .HPP 파일과 주변이 아닌 다른 방법을 포함해야합니다.

template<typename T> 
int MyClass::MyFunction() 
{ 
    ... 
} 

은 당신이 범위 기능을 확인하고 .HPP의 .H 파일을 포함하지 마십시오 :

은 그럼 당신은 .HPP 파일은 다음과 같이 될 것입니다. 컴파일러는 당신에게 화를 낼 것입니다.

이것은 본질적으로 .h 파일 내에서 함수를 정의하는 것과 동일하지만 두 개의 개별 파일을 유지할 수 있습니다. 클래스가 작고 기능이 거의 없거나 대부분의 함수가 하나의 라이너입니다. getter/setter 함수를 호출합니다. 전체 메모 파일을 만들 가치가 없을 수도 있지만 BST 및 AVL과 같은 경우 여러 개의 파일을 가지고 있으면 코드 벽을 쳐다 보지 않는 것이 좋습니다.