Fatal编程技术网
  • cplusplus/
  • C++ Helpt出现错误C2259:无法实例化抽象类

C++ Helpt出现错误C2259:无法实例化抽象类

c++

C++ Helpt出现错误C2259:无法实例化抽象类,c++,C++,我正在为家庭作业编写这个程序，直到我添加createList函数，它才抛出C2259错误。 我想不出这个问题是从哪里来的。我在C++上是相当新的，所以这可能是一个简单的解决方案，但是我完全迷失了。 以下是我的主要功能： #include <iostream> #include "binarySearchTree.h" #include "orderedLinkedList.h" using namespace std; int main() { bSearchTreeTy

我正在为家庭作业编写这个程序，直到我添加createList函数，它才抛出C2259错误。 我想不出这个问题是从哪里来的。我在C++上是相当新的，所以这可能是一个简单的解决方案，但是我完全迷失了。 以下是我的主要功能：

#include <iostream>
#include "binarySearchTree.h"
#include "orderedLinkedList.h"

using namespace std;

int main()
{
    bSearchTreeType<int>  treeRoot; //error C2259: 'bSearchTreeType<int>'
    //cannot instantiate abstract class

    orderedLinkedList<int> newList;

    int num;

    cout << "Enter numbers ending with -999" << endl;
    cin >> num;

    while (num != -999)
    {
        treeRoot.insert(num);
        cin >> num;
    }

    cout << endl << "Tree nodes in inorder: ";
    treeRoot.inorderTraversal();
    cout << endl;
    cout << "Tree Height: " << treeRoot.treeHeight()
        << endl;
    treeRoot.createList(newList);

    cout << "newList: ";
    newList.print();

    cout << endl;
    system("pause");

    return 0;
}

#包括
#包括“binarySearchTree.h”
#包括“orderedLinkedList.h”
使用名称空间std；
int main（）
{
bSearchTreeType treeRoot；//错误C2259:'bSearchTreeType'
//无法实例化抽象类
orderedLinkedList新列表；
int-num；
库特数；
while（num！=-999）
{
treeRoot.insert（num）；
cin>>num；
}
coutrlink；
}
}
}
发现退货；
}
模板
void bSearchTreeType:：insert（常量elemType和insertItem）
{
节点类型*当前；
节点类型*trailCurrent；
nodeType*newNode；
newNode=newnodeType；
新建节点->信息=插入项；
newNode->lLink=NULL；
newNode->rLink=NULL；
if（root==NULL）
{
根=新节点；
}
其他的
{
电流=根；
while（当前！=NULL）
{
牵引电流=电流；
如果（当前->信息==插入项）
{
库特林克；
}
其他的
{
当前=当前->rLink；
}
}
如果（跟踪当前->信息>插入项）
{
trailCurrent->lLink=newNode；
}
其他的
{
trailCurrent->rLink=newNode；
}
}
}
模板
void bSearchTreeType:：deleteNode（常量elemType&deleteItem）
{
节点类型*当前；
节点类型*trailCurrent；
bool-found=false；
if（root==NULL）
{
cout info>deleteItem）
{
当前=当前->lLink；
}
其他的
{
当前=当前->rLink；
}
}
}
如果（当前==NULL）
{
无法删除项目）
{
deleteFromTree（trailCurrent->lLink）；
}
其他的
{
deleteFromTree（trailCurrent->rLink）；
}
}
其他的
{
coutrlink；
删除临时文件；
}
else if（p->rLink==NULL）
{
温度=p；
p=温度->最低温度；
删除临时文件；
}
其他的
{
电流=p->lLink；
trailCurrent=NULL；
while（当前->链接！=NULL）
{
牵引电流=电流；
当前=当前->rLink；
}
p->info=当前->信息；
if（trailCurrent==NULL）
{
p->lLink=当前->lLink；
}
其他的
{
trailCurrent->rLink=当前->lLink；
}
删除当前文件；
}
}
#恩迪夫
另外，我有112%的把握我的createList函数是非常错误的，它不会创建一个随机数树，所以我也需要一些帮助

更新：binaryTree.h定义

#ifndef H_binaryTree
#define H_binaryTree

#include<iostream>

using namespace std;

//Define the node
template<class elemType>
struct nodeType
{
    elemType info;
    nodeType<elemType> *lLink;
    nodeType<elemType> *rLink;
};

template<class elemType>
class binaryTreeType
{
public:
    const binaryTreeType<elemType>& operator=(const binaryTreeType<elemType>&);
    bool isEmpty() const;
    void inorderTraversal() const;
    void preorderTraversal() const;
    void postorderTraversal() const;
    int treeHeight() const;
    int treeNodeCount() const;
    int treeLeavesCount() const;
    void destroyTree();
    virtual bool search(const elemType& searchItem) const = 0;
    virtual void insert(const elemType& insertItem) = 0;
    virtual void deleteNode(const elemType& deleteItem) = 0;
    virtual void createList(const elemType& createItem) = 0;

    binaryTreeType(const binaryTreeType<elemType>& otherTree);
    binaryTreeType();
    ~binaryTreeType();

protected:
    nodeType<elemType> *root;

private:
    void copyTree(nodeType<elemType>*& copiedTreeRoot, nodeType<elemType>* otherTreeRoot);
    void destroy(nodeType<elemType>* &p);
    void inorder(nodeType<elemType> *p)const;
    void preorder(nodeType<elemType> *p)const;
    void postorder(nodeType<elemType> *p) const;
    int height(nodeType<elemType> *p)const;
    int max(int x, int y) const;
    int nodeCount(nodeType<elemType> *p)const;
    int leavesCount(nodeType<elemType> *p)const;
};

template <class elemType>
binaryTreeType<elemType>::binaryTreeType()
{
    root = NULL;
}

template <class elemType>
bool binaryTreeType<elemType>::isEmpty() const
{
    return (root == NULL);
}

template <class elemType>
void binaryTreeType<elemType>::inorderTraversal() const
{
    inorder(root);
}

template <class elemType>
void binaryTreeType<elemType>::preorderTraversal() const
{
    preorder(root);
}

template <class elemType>
void binaryTreeType<elemType>::postorderTraversal() const
{
    postorder(root);
}

template <class elemType>
int binaryTreeType<elemType>::treeHeight() const
{
    return height(root);
}

template <class elemType>
int binaryTreeType<elemType>::treeNodeCount() const
{
    return nodeCount(root);
}

template <class elemType>
int binaryTreeType<elemType>::treeLeavesCount() const
{
    return leavesCount(root);
}

template <class elemType>
void binaryTreeType<elemType>::copyTree(nodeType<elemType>* &copiedTreeRoot,
nodeType<elemType>* otherTreeRoot)
{
    if (otherTreeRoot == NULL)
        copiedTreeRoot = NULL;
    else
    {
        copiedTreeRoot = new nodeType<elemType>;
        copiedTreeRoot->info = otherTreeRoot->info;
        copyTree(copiedTreeRoot->lLink, otherTreeRoot->lLink);
        copyTree(copiedTreeRoot->rLink, otherTreeRoot->rLink);
    }
} 

template <class elemType>
void binaryTreeType<elemType>::inorder(nodeType<elemType> *p) const
{
    if (p != NULL)
    {
        inorder(p->lLink);
        cout << p->info << " ";
        inorder(p->rLink);
    }
}

template <class elemType>
void binaryTreeType<elemType>::preorder(nodeType<elemType> *p) const
{
    if (p != NULL)
    {
        cout << p->info << " ";
        preorder(p->lLink);
        preorder(p->rLink);
    }
}

template <class elemType>
void binaryTreeType<elemType>::postorder(nodeType<elemType> *p) const
{
    if (p != NULL)
    {
        postorder(p->lLink);
        postorder(p->rLink);
        cout << p->info << " ";
    }
}

//Overload the assignment operator
template <class elemType>
const binaryTreeType<elemType>& binaryTreeType<elemType>::operator=(const binaryTreeType<elemType>& otherTree)
{
    if (this != &otherTree) //avoid self-copy
    {
        if (root != NULL) //if the binary tree is not empty,
            //destroy the binary tree
            destroy(root);

        if (otherTree.root == NULL) //otherTree is empty
            root = NULL;
        else
            copyTree(root, otherTree.root);
    }//end else

    return *this;
}

template <class elemType>
void binaryTreeType<elemType>::destroy(nodeType<elemType>* &p)
{
    if (p != NULL)
    {
        destroy(p->lLink);
        destroy(p->rLink);
        delete p;
        p = NULL;
    }
}

template <class elemType>
void binaryTreeType<elemType>::destroyTree()
{
    destroy(root);
}

//copy constructor
template <class elemType>
binaryTreeType<elemType>::binaryTreeType
(const binaryTreeType<elemType>& otherTree)
{
    if (otherTree.root == NULL) //otherTree is empty
        root = NULL;
    else
        copyTree(root, otherTree.root);
}

//Destructor
template <class elemType>
binaryTreeType<elemType>::~binaryTreeType()
{
    destroy(root);
}

template<class elemType>
int binaryTreeType<elemType>::height
(nodeType<elemType> *p) const
{
    if (p == NULL)
        return 0;
    else
        return 1 + max(height(p->lLink), height(p->rLink));
}

template <class elemType>
int binaryTreeType<elemType>::max(int x, int y) const
{
    if (x >= y)
        return x;
    else
        return y;
}

template <class elemType>
int binaryTreeType<elemType>::nodeCount(nodeType<elemType> *p) const
{
    return nodeCount(root);
}

template <class elemType>
int binaryTreeType<elemType>::leavesCount(nodeType<elemType> *p) const
{
    return leavesCount(root);
}

#endif

#ifndef H#u二进制树
#定义H_二叉树
#包括
使用名称空间std；
//定义节点
模板
结构节点类型
{
元素类型信息；
nodeType*lLink；
nodeType*rLink；
};
模板
类二进制树类型
{
公众：
const-binaryTreeType&运算符=（const-binaryTreeType&）；
bool isEmpty（）常量；
void inorderTraversal（）常量；
void preorderTraversal（）常量；
void postorderTraversal（）常量；
int treeHeight（）常量；
int treeNodeCount（）常量；
int treeleavesunt（）常量；
void树（）；
虚拟布尔搜索（const elemType&searchItem）const=0；
虚拟空插入（常量元素类型和插入项）=0；
虚拟void deleteNode（常量elemType&deleteItem）=0；
虚拟void createList（常量elemType&createItem）=0；
二进制树类型（const二进制树类型和其他树）；
二进制树类型（）；
~binaryTreeType（）；
受保护的：
节点类型*根；
私人：
void copyTree（nodeType*&copiedTreeRoot，nodeType*otherTreeRoot）；
无效销毁（节点类型*&p）；
无效顺序（节点类型*p）常量；
无效前序（节点类型*p）常数；
无效邮购（节点类型*p）常量；
内部高度（节点类型*p）常数；
int max（int x，int y）常数；
int nodeCount（nodeType*p）常量；
int leaveScont（nodeType*p）const；
};
模板
binaryTreeType:：binaryTreeType（）
{
root=NULL；
}
模板
bool binaryTreeType:：isEmpty（）常量
{
返回（root==NULL）；
}
模板
void binaryTreeType:：inorderTraversal（）常量
{
顺序（根）；
}
模板
void binaryTreeType:：preorderTraversal（）常量
{
前序（根）；
}
模板
void binaryTreeType:：postorderTraversal（）常量
{
后序（根）；
}
模板
int binaryTreeType:：treeHeight（）常量
{
返回高度（根）；
}
模板
int binaryTreeType:：treeNodeCount（）常量
{
返回nodeCount（root）；
}
模板
int binaryTreeType:：treeleavesunt（）常量
{
返叶素（根）；
}
模板
void binaryTreeType:：copyTree（节点类型*&copiedTreeRoot，
节点类型*otherTreeRoot）
{
if（otherTreeRoot==NULL）
copiedTreeRoot=NULL；
其他的
{
copiedTreeRoot=新节点类型；
copiedTreeRoot->info=otherTreeRoot->info；
copyTree（copiedTreeRoot->lLink，otherTreeRoot->lLink）；
copyTree（copiedTreeRoot->rLink，otherTreeRoot->rLink）；
}
} 
模板
void binaryTreeType:：inoorder（nodeType*p）const
{
如果（p！=NULL）
{
顺序（p->lLink）；
cout-info-rLink）；
}
}
模板
void binaryTreeType:：preorder（nodeType*p）常量
{
如果（p！=NULL）
{
cout-info-lLink）；
前序（p->rLink）；
}
}
模板
void binaryTreeType:：postorder（nodeType*p）常量
{
如果（p！=NULL）
{
邮购（p->lLink）；
邮购（p->rLink）；
cout-info-lLink）；
销毁（p->rLink）；
删除p；
p=零；
}
}
模板
美国之音

#ifndef H_binaryTree
#define H_binaryTree

#include<iostream>

using namespace std;

//Define the node
template<class elemType>
struct nodeType
{
    elemType info;
    nodeType<elemType> *lLink;
    nodeType<elemType> *rLink;
};

template<class elemType>
class binaryTreeType
{
public:
    const binaryTreeType<elemType>& operator=(const binaryTreeType<elemType>&);
    bool isEmpty() const;
    void inorderTraversal() const;
    void preorderTraversal() const;
    void postorderTraversal() const;
    int treeHeight() const;
    int treeNodeCount() const;
    int treeLeavesCount() const;
    void destroyTree();
    virtual bool search(const elemType& searchItem) const = 0;
    virtual void insert(const elemType& insertItem) = 0;
    virtual void deleteNode(const elemType& deleteItem) = 0;
    virtual void createList(const elemType& createItem) = 0;

    binaryTreeType(const binaryTreeType<elemType>& otherTree);
    binaryTreeType();
    ~binaryTreeType();

protected:
    nodeType<elemType> *root;

private:
    void copyTree(nodeType<elemType>*& copiedTreeRoot, nodeType<elemType>* otherTreeRoot);
    void destroy(nodeType<elemType>* &p);
    void inorder(nodeType<elemType> *p)const;
    void preorder(nodeType<elemType> *p)const;
    void postorder(nodeType<elemType> *p) const;
    int height(nodeType<elemType> *p)const;
    int max(int x, int y) const;
    int nodeCount(nodeType<elemType> *p)const;
    int leavesCount(nodeType<elemType> *p)const;
};

template <class elemType>
binaryTreeType<elemType>::binaryTreeType()
{
    root = NULL;
}

template <class elemType>
bool binaryTreeType<elemType>::isEmpty() const
{
    return (root == NULL);
}

template <class elemType>
void binaryTreeType<elemType>::inorderTraversal() const
{
    inorder(root);
}

template <class elemType>
void binaryTreeType<elemType>::preorderTraversal() const
{
    preorder(root);
}

template <class elemType>
void binaryTreeType<elemType>::postorderTraversal() const
{
    postorder(root);
}

template <class elemType>
int binaryTreeType<elemType>::treeHeight() const
{
    return height(root);
}

template <class elemType>
int binaryTreeType<elemType>::treeNodeCount() const
{
    return nodeCount(root);
}

template <class elemType>
int binaryTreeType<elemType>::treeLeavesCount() const
{
    return leavesCount(root);
}

template <class elemType>
void binaryTreeType<elemType>::copyTree(nodeType<elemType>* &copiedTreeRoot,
nodeType<elemType>* otherTreeRoot)
{
    if (otherTreeRoot == NULL)
        copiedTreeRoot = NULL;
    else
    {
        copiedTreeRoot = new nodeType<elemType>;
        copiedTreeRoot->info = otherTreeRoot->info;
        copyTree(copiedTreeRoot->lLink, otherTreeRoot->lLink);
        copyTree(copiedTreeRoot->rLink, otherTreeRoot->rLink);
    }
} 

template <class elemType>
void binaryTreeType<elemType>::inorder(nodeType<elemType> *p) const
{
    if (p != NULL)
    {
        inorder(p->lLink);
        cout << p->info << " ";
        inorder(p->rLink);
    }
}

template <class elemType>
void binaryTreeType<elemType>::preorder(nodeType<elemType> *p) const
{
    if (p != NULL)
    {
        cout << p->info << " ";
        preorder(p->lLink);
        preorder(p->rLink);
    }
}

template <class elemType>
void binaryTreeType<elemType>::postorder(nodeType<elemType> *p) const
{
    if (p != NULL)
    {
        postorder(p->lLink);
        postorder(p->rLink);
        cout << p->info << " ";
    }
}

//Overload the assignment operator
template <class elemType>
const binaryTreeType<elemType>& binaryTreeType<elemType>::operator=(const binaryTreeType<elemType>& otherTree)
{
    if (this != &otherTree) //avoid self-copy
    {
        if (root != NULL) //if the binary tree is not empty,
            //destroy the binary tree
            destroy(root);

        if (otherTree.root == NULL) //otherTree is empty
            root = NULL;
        else
            copyTree(root, otherTree.root);
    }//end else

    return *this;
}

template <class elemType>
void binaryTreeType<elemType>::destroy(nodeType<elemType>* &p)
{
    if (p != NULL)
    {
        destroy(p->lLink);
        destroy(p->rLink);
        delete p;
        p = NULL;
    }
}

template <class elemType>
void binaryTreeType<elemType>::destroyTree()
{
    destroy(root);
}

//copy constructor
template <class elemType>
binaryTreeType<elemType>::binaryTreeType
(const binaryTreeType<elemType>& otherTree)
{
    if (otherTree.root == NULL) //otherTree is empty
        root = NULL;
    else
        copyTree(root, otherTree.root);
}

//Destructor
template <class elemType>
binaryTreeType<elemType>::~binaryTreeType()
{
    destroy(root);
}

template<class elemType>
int binaryTreeType<elemType>::height
(nodeType<elemType> *p) const
{
    if (p == NULL)
        return 0;
    else
        return 1 + max(height(p->lLink), height(p->rLink));
}

template <class elemType>
int binaryTreeType<elemType>::max(int x, int y) const
{
    if (x >= y)
        return x;
    else
        return y;
}

template <class elemType>
int binaryTreeType<elemType>::nodeCount(nodeType<elemType> *p) const
{
    return nodeCount(root);
}

template <class elemType>
int binaryTreeType<elemType>::leavesCount(nodeType<elemType> *p) const
{
    return leavesCount(root);
}

#endif



virtual void createList(const elemType& newList) = 0 ;
                          ///                    ~~~~ shouldn't be used in derived class