C++ 如何从代码中删除类并使其继续工作？

所以在学校，我编写了代码，使用了类，但老师说我不应该使用类。
这是编辑我当前代码的一种方法，这样我就不会有类了吗？
这是一个用类创建的二元搜索树，我需要删除它。
关于做什么、删除或更改什么的信息会有所帮助，您无需编辑我的代码

    #include <iostream>
    #include <cstdlib>

using namespace std;
class BST
{
    private:
        struct tree_node
        {
           tree_node* left;
           tree_node* right;
           int data;
        };


    public:
        BST()
        {
           root = NULL;
           parent = NULL;
        }
        tree_node* root;
        tree_node* parent;

        bool isEmpty() const { return root==NULL; }
        void print_inOrder();
        void inOrder(tree_node*);
        void print_preOrder();
        void preOrder(tree_node*);
        void print_postOrder();
        void postOrder(tree_node*);
        void search(tree_node*,int,tree_node*);
        void insert(int);
        void create(int);
        void remove(int);
};

void BTS::search(tree_node* root,int k,tree_node* parent)
{

    if (root == nullptr)
    {
        cout << "Element not found"<<endl;
        return;
    }
    if (root->data == k)
    {
        if (parent == nullptr)
            cout << "element " << k << " found "; //jeigu ieskomas skaicius medzio virsune

        else cout << "element "<<k<<" found "<<endl;
        return;
    }
    if (k < root->data)
        return searcch(root->left,k, root); // rekursija jeigu reiksme mazesne uz sakny einame i kaire

    return search(root->right,k,root);// rekursija jeigu reiksme mazesne uz sakny einame i desine
}

void BTS::create(int d)
{
    for(int i=0;i<d;i++)
    {
    tree_node* t = new tree_node;
    tree_node* parent;
    cout<<"enter element"<<endl;
    cin>>t->data;
    t->left = NULL;
    t->right = NULL;
    parent = NULL;

    if(isEmpty()) root = t;
    else
    {
        tree_node* current;
        current = root;
        while(current)
        {
            parent = current;
            if(t->data > current->data) current = current->right;
            else current = current->left;
        }

        if(t->data < parent->data)
           parent->left = t;
        else
           parent->right = t;
    }
    }
}

void BTS::remove(int d)
{
    bool found = false;
    if(isEmpty())
    {
        cout<<" tree is empty "<<endl;
        return;
    }
    tree_node* curr;
    tree_node* parent;
    curr = root;

    while(curr != NULL)
    {
         if(curr->data == d)
         {
            found = true;
            break;
         }
         else
         {
             parent = curr;
             if(d>curr->data) curr = curr->right;
             else curr = curr->left;
         }
    }
    if(!found)
         {
        cout<<" element not found"<<endl;
        return;
    }


    if((curr->left == NULL && curr->right != NULL)|| (curr->left != NULL
&& curr->right == NULL))
    {
       if(curr->left == NULL && curr->right != NULL)
       {
           if(parent->left == curr)
           {
             parent->left = curr->right;
             delete curr;
           }
           else
           {
             parent->right = curr->right;
             delete curr;
           }
       }
       else
       {
          if(parent->left == curr)
           {
             parent->left = curr->left;
             delete curr;
           }
           else
           {
             parent->right = curr->left;
             delete curr;
           }
       }
     return;
    }
         if( curr->left == NULL && curr->right == NULL)
    {
        if(parent->left == curr) parent->left = NULL;
        else parent->right = NULL;
                 delete curr;
                 return;
    }
    if (curr->left != NULL && curr->right != NULL)
    {
        tree_node* chkr;
        chkr = curr->right;
        if((chkr->left == NULL) && (chkr->right == NULL))
        {
            curr = chkr;
            delete chkr;
            curr->right = NULL;
        }
        else
        {
            if((curr->right)->left != NULL)
            {
                tree_node* lcurr;
                tree_node* lcurrp;
                lcurrp = curr->right;
                lcurr = (curr->right)->left;
                while(lcurr->left != NULL)
                {
                   lcurrp = lcurr;
                   lcurr = lcurr->left;
                }
        curr->data = lcurr->data;
                delete lcurr;
                lcurrp->left = NULL;
           }
           else
           {
               tree_node* tmp;
               tmp = curr->right;
               curr->data = tmp->data;
           curr->right = tmp->right;
               delete tmp;
           }

        }
         return;
    }

}

void BTS::print_inOrder()
{
  inOrder(root);
}

void BTS::inOrder(tree_node* p)// naudojant rekursija atspausdinu medi vidniu apejimu
{
    if(p != NULL)
    {
        if(p->left) inOrder(p->left);
        cout<<" "<<p->data<<" ";
        if(p->right) inOrder(p->right);
    }
    else return;
}


void BTS::print_preOrder()
{
    preOrder(root);
}

void BTS::preOrder(tree_node* p)// naudojant rekursija atspausdinu medi tiesioginu apejimu
{
    if(p != NULL)
    {
        cout<<" "<<p->data<<" ";
        if(p->left) preOrder(p->left);
        if(p->right) preOrder(p->right);
    }
    else return;
}

void BTS::print_postOrder()
{
    postOrder(root);
}

void BTS::postOrder(tree_node* p) // naudojant rekursija atspausdinu medi atvikstiniu apejiu
{
    if(p != NULL)
    {
        if(p->left) postOrder(p->left);
        if(p->right) postOrder(p->right);
        cout<<" "<<p->data<<" ";
    }
    else return;
}
void BTS::insert(int d)
{
    tree_node* t = new tree_node;
    tree_node* parent;
    t->data = d;
    t->left = NULL;
    t->right = NULL;
    parent = NULL;

    if(isEmpty()) root = t;
    else
    {
        tree_node* current;
        current = root;
        while(current)
        {
            parent = current;
            if(t->data > current->data) current = current->right;
            else current = current->left;
        }

        if(t->data < parent->data)
           parent->left = t;
        else
           parent->right = t;
    }
}

int main()
{
    BTS b;
    int punktas=0,c,d;

       cout<<endl<<endl;
       cout<<" MENU "<<endl;
       cout<<" ----------------------------- "<<endl;
       cout<<" 1) sukurti "<<endl;
       cout<<" 2) tiesioginis elementu spausdinimas "<<endl;
       cout<<" 3) vidinis elementu spausdinimas "<<endl;
       cout<<" 4) atvirkstinis elementu spausdinimas "<<endl;
       cout<<" 5) iterpti nauja elementa "<<endl;
       cout<<" 6) reiksmes trinimas "<<endl;
       cout<<" 7) reiksmes paieska "<<endl;
       cout<<" 0) Iseiti "<<endl;
       cout<<" Iveskite norima punkta"<<endl;
       cin>>punktas;
       int tikrinimas = 1;

       while(punktas!=0)
       {

           if(punktas==1)
           {cout<<"Kiek reiksmiu bus sarase?"<<endl;
                    cin>>c;
                    b.sukurti(c); //panaudojam klases sukurti funckija
                    tikrinimas = 0;
           }
           else if(punktas==2 && tikrinimas == 0)
                    {
                    cout<<" tiesioginis atspausdinimas "<<endl;
                    cout<<" -------------------"<<endl;
                    b.print_tiesioginis();// panaudojam klases tiesioginis atspausdinias funckija
                    }
           else if(punktas==3 && tikrinimas == 0)
                    {
                    cout<<" vidinis atspausdinimas "<<endl;
                    cout<<" -------------------"<<endl;
                    b.print_vidinis();// panaudoja klases funkcija
                    }
           else if(punktas==4 && tikrinimas == 0)
                    {
                    cout<<" atvirkstinis atspausdinimas "<<endl;
                    cout<<" --------------------"<<endl;
                    b.print_atvirkstinis();// panaudoja klases funkcija
                    }
           else if(punktas==5 && tikrinimas == 0)
                    {cout<<"elemento iterpimas"<<endl;
                     cout<<" --------------------"<<endl;
                     cin>>c;
                     b.iterpti(c);// panaudoja klases funkcija
                    }
           else if(punktas==6 && tikrinimas == 0)
                    {
                    cout<<" iveskite elementa kuri norite istrinti "<<endl;
                    cin>>d;
                    b.salinti(d);// panaudoja klases funkcija
                    }
           else if(punktas==7 && tikrinimas == 0)
                    {
                    cout<<"iveskite reiksme kuria norite surasti"<<endl;
                    cin>>c;
                    b.paieska(b.root,c,b.tevas);
                    }
                    else if(punktas<8){cout<<"sukurkyte medi norit atlikti punktus"<<endl;}
         cout<<"iveskite kita punkta"<<endl;
         cin>>punktas;
       }
}

#包括
#包括
使用名称空间std；
BST级
{
私人：
结构树节点
{
树节点*左；
树节点*右；
int数据；
};
公众：
BST（）
{
root=NULL；
parent=NULL；
}
树节点*根；
树节点*父节点；
bool isEmpty（）常量{return root==NULL；}
作废打印顺序（）；
按顺序无效（树节点*）；
无效打印_预订单（）；
空前序（树节点*）；
作废打印_postOrder（）；
作废后订单（树节点*）；
无效搜索（树节点*，整数，树节点*）；
空白插入（int）；
无效创建（int）；
无效删除（int）；
};
void BTS:：搜索（树节点*根，整数k，树节点*父）
{
if（root==nullptr）
{
cout-right=t；
}
}
}
无效BTS:：删除（int d）
{
bool-found=false；
if（isEmpty（））
{
库特里赫特；
否则当前=当前->左侧；
}
}
如果（！找到）
{
coutright==NULL）
{
if（curr->left==NULL&&curr->right！=NULL）
{
如果（父->左==当前）
{
父项->左=当前->右；
删除curr；
}
其他的
{
父项->右=当前->右；
删除curr；
}
}
其他的
{
如果（父->左==当前）
{
父项->左=当前->左；
删除curr；
}
其他的
{
父项->右=当前->左；
删除curr；
}
}
返回；
}
if（curr->left==NULL&&curr->right==NULL）
{
如果（父项->左==curr）父项->左=NULL；
else parent->right=NULL；
删除curr；
返回；
}
if（curr->left！=NULL&&curr->right！=NULL）
{
树节点*chkr；
chkr=当前->右侧；
如果（（chkr->left==NULL）和&（chkr->right==NULL））
{
curr=chkr；
删除chkr；
当前->右=空；
}
其他的
{
如果（（当前->右侧）->左侧！=NULL）
{
树节点*lcurr；
树节点*lcurrp；
lcurrp=当前->右侧；
lcurr=（当前->右）->左；
while（lcurr->left！=NULL）
{
lcurrp=lcurr；
lcurr=lcurr->左；
}
当前->数据=当前->数据；
删除lcurr；
lcurrp->left=NULL；
}
其他的
{
树节点*tmp；
tmp=当前->右侧；
当前->数据=tmp->数据；
当前->右侧=tmp->右侧；
删除tmp；
}
}
返回；
}
}
无效BTS:：打印顺序（）
{
顺序（根）；
}
void BTS:：inoder（tree_node*p）//naudojant rekursija atspaausdinu medi vidniu apejimu
{
如果（p！=NULL）
{
如果（p->left）按顺序（p->left）；
库特里赫特）；
当前->数据）当前=当前->右侧；
否则当前=当前->左侧；
}
if（t->datadata）
父->左=t；
其他的
父->右=t；
}
}
int main（）
{
基站b；
int punktas=0，c，d；
cout您在这里没有充分利用类

您已经创建了一个名为
b
的
paieskosMedis
，并将一些应用程序逻辑放入其数据成员和成员函数中

所以只要把它们移到自由函数和全局变量中就行了。这可能是你老师想要的

例如，这：

class Foo
{
public:
   Foo() { m = 3; }
   void bar() { m = 4; }
private:
   int m;
};

int main()
{
   Foo f;
   f.bar();
}

变成：

int m;

void bar() { m = 4; }

int main()
{
   m = 3;
   bar();
}

而且，万岁，你可能已经解决了下周要完成的任务。谢谢你的帮助，如果我惹恼了你，我会很抱歉的。
将移动成员函数固定到自由函数中。< /p> TEVA=父。SalINTI = Reun.Prtt***** =不同类型的遍历。代码主要用于打印。ItPtII=将树插入一个数字。IsKoTI=搜索。这与jQuery有什么关系？等等。您正在使用C++来进行项目，而您的老师说不使用类？嗯…r您的老师正在吸烟，或者您没有透露一些项目授权。您不能。也许他们的意思是“执行”代码应该都在
main
和非成员函数中。但是
tree\u node
不会改变。也许您的老师没有意识到
struct
意味着“类”.你的老师告诉你不要上课？我希望不是这样，只是有一个误会。我建议你和老师确认一下。谢谢你，在读了你的评论之后，我请了一段时间假，然后我设法纠正了it@Pagurklis伟大的