C++ 如何对BST树中的数字乘积进行充电？

我在BST树中编写了收取产品编号的模板，但控制台在主目录中显示了任何问题。我不知道如何解决这个问题。我希望有人能告诉我哪里出了错。我认为该模板是可以的，我在main中犯了任何错误，但我没有看到这个错误。如果有人告诉我这个错误，我将不胜感激

#include <iostream>

using namespace std;


template<typename TData>
class BST {
    public:
        class BSTNode {
            public:
                BSTNode(const TData& d):left(NULL),right(NULL),data(d)
                {};
                BSTNode *left, *right;
                TData data;
        };

    protected:
        typedef BSTNode* PBSTNode;
        PBSTNode root;

    private:
        bool Insert_tmp(PBSTNode &ptr,const TData &d);
        void PreOrder_tmp(PBSTNode ptr)const;
        void InOrder_tmp(PBSTNode ptr)const;
        void PostOrder_tmp(PBSTNode ptr)const;
        void DeleteTree(PBSTNode &ptr);
        int Iloczyn(PBSTNode ptr);

    public:
        BST();
        BST(const BST<TData>&); // aby zablokować konstruktor kopiujący nie implementujemy go
        bool Insert(const TData& d);
        void PreOrder()const;
        void InOrder()const;
        void PostOrder()const;
        bool Delete(const TData& d);
        int Iloczyn();
        ~BST();
};


template<typename TData>
BST<TData>::BST()
{
    root=NULL;
}

template<typename TData>
bool BST<TData>::Insert(const TData& d)
{
    return Insert_tmp(root,d);
}

template<typename TData>
void BST<TData>::PreOrder()const
{
    if( root != NULL )
    {
        std::cout<<root->data<<", ";
        PreOrder_tmp(root->left);
        PreOrder_tmp(root->right);
        std::cout<<std::endl;
    }
}

template<typename TData>
void BST<TData>::InOrder()const
{
    if( root != NULL )
    {
        InOrder_tmp(root->left);
        std::cout<<root->data<<", ";
        InOrder_tmp(root->right);
        std::cout<<std::endl;
    }
}

template<typename TData>
void BST<TData>::PostOrder()const
{
    if( root != NULL )
    {
        PostOrder_tmp(root->left);
        PostOrder_tmp(root->right);
        std::cout<<root->data<<", ";
        std::cout<<std::endl;
    }
}

template<typename TData>
bool BST<TData>::Delete(const TData& d)
{
    PBSTNode    parent, //rodzic
                del,    //usuwany
                rem;    //zamienny

    parent = NULL;
    del=root;

    while( del != NULL && del->data != d )
    {
        parent=del;
        if( d < parent->data )
            del=del->left;
        else
            del=del->right;
    }

    // czy jest d na drzewie
    if( del == NULL )
        return false;

    // znaleziono element d


    if( del->left == NULL && del->right == NULL ) // przypadek: lisc
    {
        if( parent != NULL )
        {
            if( parent->data > del->data )
                parent->left=NULL;
            else
                parent->right=NULL;
        }
        else
            root == NULL;

        delete del;
    }
    else
    {
        if ( del->left == NULL || del->right == NULL ) // jedno poddrzewo
        {
            if( del->left == NULL )
                rem = del->right;
            else
                rem = del->left;
            *del=*rem;
        }
        else // są oba poddrzewa
        {
            parent = del;
            rem = del->left;
            while( rem->right != NULL )
            {
                parent = rem;
                rem = rem->right;
            }

            del->data = rem->data;

            if( parent == del )
                parent->left = rem->left;
            else
                parent->right = rem->left;
        }
        delete rem;
    }
    return true;
}

template<typename TData>
BST<TData>::~BST()
{
    if( root != NULL )
        DeleteTree(root);
}

template<typename TData>
bool BST<TData>::Insert_tmp(PBSTNode &ptr,const TData &d)
{
        if( ptr == NULL )
        {
            PBSTNode tmp;
            try
            {
                tmp=new BSTNode(d); // jezeli nie bedzie miejsca w pamieci to wystai tu wyjatek
                ptr=tmp;

                return true;
            }
            catch(...)
            {
                return false;
            }
        }

        if (d < ptr->data)
        {
            return Insert_tmp(ptr->left,d);
        }
        else if ( d > ptr->data )
        {
            return Insert_tmp(ptr->right,d);
        }
        else
        {
            return false; // gdy jest juz wartosc d w drzewie, w tej implementacji nie wstawiamy dwa razy tej samej wartosc
        }
}

template<typename TData>
void BST<TData>::PreOrder_tmp(PBSTNode ptr)const
{
    if( ptr != NULL )
    {
        std::cout<<ptr->data<<", ";
        PreOrder_tmp(ptr->left);
        PreOrder_tmp(ptr->right);
    }
}

template<typename TData>
int BST<TData>::Iloczyn(PBSTNode ptr)
{
    if(ptr==NULL)
    return 1;
    else
        return (ptr->PBSTNode *Iloczyn(ptr->left)*Iloczyn(ptr->right));


}

template<typename TData>
void BST<TData>::InOrder_tmp(PBSTNode ptr)const
{
    if( ptr != NULL )
    {
        InOrder_tmp(ptr->left);
        std::cout<<ptr->data<<", ";
        InOrder_tmp(ptr->right);
    }
}

template<typename TData>
void BST<TData>::PostOrder_tmp(PBSTNode ptr)const
{
    if( ptr != NULL )
    {
        PostOrder_tmp(ptr->left);
        PostOrder_tmp(ptr->right);
        std::cout<<ptr->data<<", ";
    }
}

template<typename TData>
void BST<TData>::DeleteTree(PBSTNode &ptr)
{
    if( ptr != NULL )
    {
        DeleteTree(ptr->left);
        DeleteTree(ptr->right);
        //cout<<"Del: "<<ptr->data<<", ";
        delete ptr;
    }
}


int main()
{
     cout << "Drzewa BST" << endl;

    BST<int> drzewo;

    drzewo.Insert(5);
    drzewo.Insert(-2);
    drzewo.Insert(13);
    drzewo.Insert(1);
    drzewo.Insert(0);
    drzewo.Insert(-2);
    drzewo.Insert(14);

    drzewo.PreOrder();
    cout<<drzewo.Iloczyn();

    return 0;
}

#包括
使用名称空间std；
样板
BST级{
公众：
类节点{
公众：
BSTNode（常量TData&d）：左（空）、右（空）、数据（d）
{};
BSTNode*左，*右；
TData数据；
};
受保护的：
typedef BSTNode*PBSTNode；
PBSTNode根；
私人：
bool Insert_tmp（PBSTNode&ptr、const TData&d）；
无效预订单tmp（PBSTNode ptr）常量；
void inoder_tmp（PBSTNode ptr）const；
void post order_tmp（PBSTNode ptr）const；
void deletetetree（PBSTNode和ptr）；
int-Iloczyn（PBSTNode-ptr）；
公众：
BST（）；
BST（const BST&）///aby zablokowaćkostruktor kopiujący nie implementujemy go
bool Insert（const TData&d）；
void PreOrder（）常量；
void inoorder（）常量；
void PostOrder（）常量；
bool Delete（const TData&d）；
int-Iloczyn（）；
~BST（）；
};
样板
BST:：BST（）
{
root=NULL；
}
样板
bool BST:：插入（常量TData&d）
{
返回Insert_tmp（根，d）；
}
样板
void BST:：PreOrder（）常量
{
if（root！=NULL）
{
std:：coutdata）
父->左=空；
其他的
父->右=空；
}
其他的
root==NULL；
删除del；
}
其他的
{
如果（del->left==NULL | | del->right==NULL）//jedno poddrzewo
{
如果（del->left==NULL）
rem=del->right；
其他的
rem=del->left；
*del=*rem；
}
else//sąoba poddrzewa
{
父代=del；
rem=del->left；
while（rem->right！=NULL）
{
父母=rem；
rem=rem->右侧；
}
del->data=rem->data；
如果（父项==del）
父->左=rem->左；
其他的
父->右=rem->左；
}
删除rem；
}
返回true；
}
样板
BST:：~BST（）
{
if（root！=NULL）
删除树（根）；
}
样板
bool BST:：Insert_tmp（PBSTNode&ptr、const TData&d）
{
如果（ptr==NULL）
{
PBSTNode-tmp；
尝试
{
tmp=新BSTNode（d）；//jezeli nie bedzie miejsca w pamieci to wystai tu wyjatek
ptr=tmp；
返回true；
}
捕获（…）
{
返回false；
}
}
如果（数据）
{
返回Insert_tmp（ptr->left，d）；
}
否则如果（d>ptr->数据）
{
返回Insert_tmp（ptr->right，d）；
}
其他的
{
返回false；//gdy jest juz wartosc d w drzewie，w tej implementacji nie wstawimy dwa razy tej samej wartosc
}
}
样板
void BST:：预订单_tmp（PBSTNode ptr）常量
{
如果（ptr！=NULL）
{
std:：coutPBSTNode*Iloczyn（ptr->left）*Iloczyn（ptr->right））；
}
样板
void BST:：inoder_tmp（PBSTNode ptr）常量
{
如果（ptr！=NULL）
{
顺序\u tmp（ptr->左）；
std：：coutright）；
std:：cout在
BST
定义中，您声明了成员函数
int Iloczyn（）；
但尚未实现它

您需要添加以下内容：

template<typename TData>
int BST<TData>::Iloczyn() {
    return 0;                  // or whatever int you'd like to return
}

模板
int BST:：Iloczyn（）{
返回0；//或任何要返回的int
}

但是，您不应从该函数返回
int
。节点类型为
TData
，因此您应该返回
TData

Iloczyn（）
中的乘法过程将始终返回
1
，因为乘法中从不包含当前节点的数据值

这些问题和许多其他问题都在这方面得到了纠正

注意：不要
typedef
指针类型。这只会使其难以读取。
对BST:：Iloczyn（）和ld的未定义引用返回1个退出状态。此错误主要显示在coutYes旁边，您尚未实现
模板int BST:：Iloczyn（）
我看到了这个代码，我真的不知道我必须做什么，我看到了，我觉得一切都很好
ptr->PBSTNode
看起来你拼错了
ptr->data
@MateuszWojno我想我已经在我的回答中涵盖了你问的所有问题，但是如果我没有，你能澄清你的问题吗？我们不知道你有什么错误你得到了。你得到了编译错误还是运行时错误？对我来说，添加上述内容使程序编译和运行都没有问题：我添加了你的代码，现在一个程序没有显示错误，但模板返回了我0，后来我从树中删除了0，添加了2。一个程序仍然返回0。@MateuszWojno我不知道你对函数的期望是什么为了返回，我只在函数中添加了
0
。我在该行上做了注释。更改该行，使其返回您希望返回的内容。template int BST:：Iloczyn（）{if（root==NULL）返回1；else返回（root->PBSTNode*Iloczyn（root->left）*Iloczyn Iloczyn（root->right））；}现在一个程序向我显示了更多的错误。@MateuszWojno我修复了我认为你提到的问题。如果你在这之后发现了更多问题，请在SO发布一个新问题。