Allouer un objet de type classe abstraite C++ Xcode

Question

TreeInterface.h

#ifndef TreeInterface_h 
#define TreeInterface_h 
#include"PreconditionException.h" 
#include"NotFoundException.h" 
//#include"Tree.hpp" 
template<class ItemType> 
class TreeInterface //: public binarySearchTree<ItemType> 
{ 
    virtual void clear()=0; 
    virtual bool isEmpty()const=0; 
    virtual int getHeight()=0; 
    virtual ItemType getRootData() const throw(precondViolated)=0; 
    virtual bool add(const ItemType& item)=0; 
    virtual void setItem()=0; 
    virtual int getNumberOfNodes()const=0; 
    //virtual ItemType getEntry(const ItemType& anEntry) const throw(NotFoundException)=0; 
    // int getNumberOfNodes()const; 
    //virtual void setRootData(const ItemType& item)=0; 
    //virtual void inorder()=0; 
}; 
#endif /* TreeInterface_h */ 

J'essaie de créer un arbre binaire mais j'ai un problème avec classe abstraite. Lorsque j'essaie de créer une nouvelle instance de la classe binarySearchTree, il me donne une erreur: Allocating an object of abstract class type "binarySearchTree". J'ai vérifié toutes mes fonctions. Je ne sais pas quoi faire. Je pensais que le problème est d'inclure différents fichiers tels que Node.cpp, je ne suis pas sûr à ce sujet. J'apprécierais de l'aide.

Tree.h

#ifndef Tree_h 
#define Tree_h 
#include"TreeInterface.h" 
#include"Node.h" 
//#include"tree.cpp" // should be correct 
#include <stdio.h> 
#include <iostream> 
#include<cstdlib> 
#include"PreconditionException.h" 
#include "NotFoundException.h" 
using namespace std; 
template<class ItemType> 
class binarySearchTree: public TreeInterface<ItemType> 
{ 
private: 
    node<ItemType>* rootPtr; 
protected: 
int getHeightHelp(node<ItemType>* subTreePtr)const; 

void destroyTree(node<ItemType>* subTreePtr); 

node<ItemType>* balancedAdd(node<ItemType>* subTreePtr,node<ItemType>* newNodePtr); 

node<ItemType>* copyTree(const node<ItemType>* treePtr) const; 
public: 
binarySearchTree(); 

binarySearchTree(const ItemType& rootItem); 

binarySearchTree(const ItemType& rootItem,binarySearchTree<ItemType>* leftPart,binarySearchTree<ItemType>* rightPart); 

binarySearchTree(const binarySearchTree<ItemType>& treePtr); 

void clear(); 
bool isEmpty()const; 
int getHeight(); 
bool add(const ItemType& item); 
ItemType getRootData() const throw(precondViolated); 
int getNumberOfNodes(node<ItemType>* subtree)const; 
void setItem(ItemType item); 
}; 

` Node.h

#ifndef Node_h 
#define Node_h 

#include <stdio.h> 
#include<iostream> 
using namespace std; 
template<class ItemType> 
class node 
{ 
private: 
ItemType data; 
node<ItemType>* left; 
node<ItemType>* right; 
public: 
node(); 
node(const ItemType &newdata); 
node(const ItemType& item,node<ItemType>* leftPtr,node<ItemType>*  rightPtr); 
ItemType getNodeItem(); 
ItemType* getLeftPtr(); 
ItemType* getRightPtr(); 
void setLeft(node<ItemType>* newleft); 
void setRight(node<ItemType>* newright); 
void setNodeItem(ItemType& item); 
bool isLeaf() const; 
}; 

L'erreur vient quand je tente de créer une nouvelle instance de binarySearchTree. main.cpp

#include <iostream> 
#include<cstdlib> 
#include<string> 
#include"Tree.h" 
using namespace std; 
int main() 
{ 
int num=11; 
binarySearchTree<int>* node=new binarySearchTree<int>(); //the error is here. Allocating an object of abstract class type "binarySearchTree" 
node->add(9); 
node->isEmpty(); 
} 

Answer 1

Comme xaxxon a souligné le lien, si vous avez une classe abstraite (où fonction virtuelle = 0) alors toutes les fonctions de la classe de base doivent être supplantée pour pour instancier un objet de la classe dérivée. Votre erreur de compilation vous indique que vous n'avez pas écrasé toutes les fonctions.

Dans votre cas, votre problème est légèrement plus subtil. Considérez ce qui suit:

class Abstract 
{ 
public: 
    virtual bool MyFunction(int x) = 0; 
}; 

class Concrete : public Abstract 
{ 
public: 
    bool MyFunction()  // This does not override Abstract::MyFunction because it is "overloaded", parameters are different 
    { 
     return true; 
    } 
}; 

int main() 
{ 
    Concrete concrete; 
    return 0; 
} 

Bien qu'il puisse sembler que nous sommes trop à cheval MyFunction, ce n'est pas le cas parce que les paramètres sont différents (classe de base a int x). Ce n'est donc pas la même fonction et le Béton est encore une classe abstraite.

Comparez vos fonctions: void setItem(ItemType item); ne va pas à plus-ride virtual void setItem()=0; dans la classe de base