C++ Vorlage binäre Suchbaum - Argument list Fehler

Question

Was ich will ist eine ziemlich einfache binäre Suchbaum, der über die Vorlage Tag, ermöglicht die Verwendung von numerischen Daten in ihm verwendet werden, aber ich habe einige ziemlich anstößige Probleme, die ich habe keine Ahnung, wie man sich davon befreien kann, wenn jemand helfen kann, würde es sehr geschätzt werden. Die Fehlermeldung, die für mich auftaucht, ist "Ungültige Verwendung von Schablonenname 'BST' ohne eine Argumentliste" - und ehrlich gesagt habe ich keine Ahnung, wie man es löst. Es tritt in Zeile 31, 89, 105, 120, 130, 141 in der bst.cpp-Datei auf. Angesichts der Tatsache, dass ich bin bin nicht so kompetent, wenn es um binäre Suchbäume geht, würde ich so schlüssig einer Antwort wie möglich vorziehen (sogar soweit gehen, genau zu erwähnen, wo und was geändert werden muss):

main.cpp

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

using namespace std; 

int main() 
{ 

    BST <int> tree; 
    tree.insert(8); 
    tree.insert(25); 
    tree.insert(99); 
    tree.insert(20); 
    tree.insert(25); 
    tree.insert(20); 
    tree.insert(2); 
    tree.insert(89); 
    tree.insert(15); 
    tree.insert(10); 
    tree.insert(30); 
    tree.insert(50); 
    tree.displayorder(); 



    int number; 

    int Inputnumber; 
    while (true){ 
     cout << "Choose what you want to do: " << endl << "1# Insert" << endl << "2# Display Orders" << endl << "3# Search" << endl << "4# Delete" << endl << endl << endl; 
     cin >> Inputnumber; 
     if (Inputnumber==1){ 
      cout << endl << "Enter the number you want inserted: "; 
      cin >> number; 
      tree.insert(number); 
      cout << endl << endl << endl; 
     } 
     if (Inputnumber==2){ 
      cout<<"Display Orders: " << endl; 
      tree.displayorder(); 
      cout << endl << endl << endl; 
     } 

     if (Inputnumber==3){ 
      cout<<"Enter the number you want to search for: "; 
      cin >> number; 
      tree.search(number); 
      cout << endl << endl << endl; 
     } 
     if (Inputnumber==4){ 
      cout << "Enter the number you want to remove: "; 
      cin >> number; 
      tree.remove(number); 
      cout << endl << endl << endl; 
     } 
    } 
} 

BST.cpp

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

using namespace std; 

template <class T> 
void BST<T>::preorder(node* tree) 
{ 
    if(tree == NULL){ 
     return; 
    } 
    cout << tree->data << " "; 
    inorder(tree->left); 
    inorder(tree->right); 
} 



template <class T> 
void BST<T>::postorder(node* tree) 
{ 
    if(tree == NULL){ 
     return; 
    } 
    inorder(tree->left); 
    inorder(tree->right); 
    cout << tree->data << " "; 
} 

template <typename T> 
BST::node* BST<T>::find(node* tree, T x)  //ERROR HERE 
{ 
    if(tree == NULL) 
     return NULL; 
    else if(x < tree->data) 
     return find(tree->left, x); 
    else if(x > tree->data) 
     return find(tree->right, x); 
    else 
     return tree; 
} 
template <typename T> 
BST<T>::BST() 
{ 
    root = NULL; 
} 

template <typename T> 
BST<T>::~BST() 
{ 
    root = makeEmpty(root); 
} 

template <class T> 
void BST<T>::insert(T x) 
{ 
    root = insert(x, root); 
} 

template <class T> 
void BST<T>::remove(T x) 
{ 
    root = remove(x, root); 
} 

template <class T> 
void BST<T>::displayorder() 
{ 
    inorder(root); 
    cout << endl; 
    preorder(root); 
    cout << endl; 
    postorder(root); 
    cout << endl << endl; 
} 

template <class T> 
void BST<T>::search(T x) 
{ 
    if(root = find(root, x)){ 
     cout << endl << "Found!" << endl; 
    } 
    else{ 
     cout << endl << "Not Found!" << endl; 
    } 
} 

template <class T> 
BST::node* BST<T>::makeEmpty(node* tree)  //ERROR HERE 
{ 
    if(tree == NULL) 
     return NULL; 
    { 
     makeEmpty(tree->left); 
     makeEmpty(tree->right); 
     delete tree; 
    } 
    return NULL; 
} 




template <class T> 
BST::node* BST<T>::insert(T x, node* tree)  //ERROR HERE 
{ 
    if(tree == NULL) 
    { 
     tree = new node; 
     tree->data = x; 
     tree->left = tree->right = NULL; 
    } 
    else if(x < tree->data) 
     tree->left = insert(x, tree->left); 
    else if(x >= tree->data) 
     tree->right = insert(x, tree->right); 
    return tree; 
} 

BST::node* BST::findMin(node* tree)    //ERROR HERE 
{ 
    if(tree == NULL) 
     return NULL; 
    else if(tree->left == NULL) 
     return tree; 
    else 
     return findMin(tree->left); 
} 

BST::node* BST::findMax(node* tree)    //ERROR HERE 
{ 
    if(tree == NULL) 
     return NULL; 
    else if(tree->right == NULL) 
     return tree; 
    else 
     return findMax(tree->right); 
} 

template <typename T> 
BST::node* BST<T>::remove(T x, node* tree)  //ERROR HERE 
{ 
    node* temp; 
    if(tree == NULL) 
     return NULL; 
    else if(x < tree->data) 
     tree->left = remove(x, tree->left); 
    else if(x > tree->data) 
     tree->right = remove(x, tree->right); 
    else if(tree->left && tree->right) 
    { 
     temp = findMin(tree->right); 
     tree->data = temp->data; 
     tree->right = remove(tree->data, tree->right); 
    } 
    else 
    { 
     temp = tree; 
     if(tree->left == NULL) 
      tree = tree->right; 
     else if(tree->right == NULL) 
      tree = tree->left; 
     delete temp; 
    } 

    return tree; 
} 

template <class T> 
void BST<T>::inorder(node* tree) 
{ 
    if(tree == NULL){ 
     return; 
    } 
    inorder(tree->left); 
    cout << tree->data << " "; 
    inorder(tree->right); 
} 

BST.h

#ifndef BST_H 
#define BST_H 


template <class T> 
class BST 
{ 
    struct node 
    { 
     T data; 
     node* left; 
     node* right; 
    }; 

    node* root; 

    node* makeEmpty(node* tree); 

    node* insert(T x, node* tree); 

    node* findMin(node* tree); 

    node* findMax(node* tree); 

    node* remove(T x, node* tree); 

    void inorder(node* tree); 

    void preorder(node* tree); 



    void postorder(node* tree); 


public: 
    BST(); 

    ~BST(); 


    node* find(node* tree, T x); 

    void insert(T x); 

    void remove(T x); 

    void displayorder(); 

    void search(T x); 
}; 

#endif // BST_H 

Answer 1

von Beispiel in

BST::node* BST<T>::find(node* tree, T x) 

Sie die <T> Komponente zum ersten BST vergessen.

Sollte

// vvv 
BST<T>::node* BST<T>::find(node* tree, T x) 

Alle anderen Fehler sind vom gleichen Typ sein.

Answer 2

Eine Klassenvorlage wie die BST, die Sie anscheinend verwenden, ist kein Typ. Es ist ein Rezept zum Erstellen eines Klassentyps. Was die Fehlermeldung Ihnen zu sagen versucht, ist, dass Sie (fast) überall, wo Sie den Namen BST verwenden, Vorlagenargumente unmittelbar nach der Eingabe in < spitze Klammern > liefern müssen.

Zum Beispiel in

template <class T> 
BST::node* BST<T>::makeEmpty(node* tree)  //ERROR HERE 

die Compiler über die erste Instanz von BST in dem Rückgabetyp beschwert, nicht derjenige, der richtig BST<T> als Klassentyp angibt. Dies sollte wahrscheinlich sein:

template <class T> 
BST<T>::node* BST<T>::makeEmpty(node* tree) 

[Es gibt mindestens zwei Ausnahmen von dieser allgemeinen Regel. Zum einen kann der Name einer Vorlage allein als Vorlageargument für eine andere Vorlage verwendet werden, die anstelle eines Typs oder Werts eine Vorlage erwartet.

Die andere wird als "Name der injizierten Klasse" bezeichnet: Innerhalb des Bereichs einer Klassenvorlage, einschließlich eines Klassenvorlagenelements, können Sie nur den Namen der Vorlage als Alias ​​für die Spezialisierung "current" verwenden.

So in der Tat könnte man auch einen nachgestellten Rückgabetyp verwenden und zu tun:

template <class T> 
auto BST<T>::makeEmpty(node* tree) -> BST::node* 

Im oben, da die Art Rückkehr nun nach den BST<T>:: kommt und auch nicht vor, ist es nun im Rahmen der Klassenvorlage, so dürfen Sie nur BST als Alias ​​für BST<T> verwenden.]