如何在BST树中对数字的乘积收费?

我写了在BST树中收取产品编号的模板，但控制台在main中向我展示了任何问题。我不知道如何解决这个问题。我希望有人告诉我我哪里犯了错误。我认为该模板没问题，我在 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;
}