Is it possible to derive a tree from two different parent classes in C++?

[abejary]

Hi guys, I’ve been given a task in which my teachers even cannot help me through! I wonder how can I derive a tree from two different parent classes in C++; i.e. which parameters should be from the first and which from the second? I tried putting the left and right pointers in the second and the data in the first, but due to the difference in types, I am not able to use them?
Thanks by the way,

[weaknessforcats]

I would need to see your class declaration code.

I assume all of your data is private, that you are using virtul base classes and following the multiple inheritance constructor rules.

Multiple inheritance is not a requirement in OOP but it can lead to elegant solutions.

[abejary]

#include<iostream.h>
#include<iomanip.h>
#include<assert.h>
class treenode{
    friend class tree;
    public:
 
        treenode(const int &d):leftptr(0),data(d),rightptr(0){cout<<"base"<<endl;}
        int getdate() const{return data;}
 
    private:
        treenode *leftptr;
        int data;
        treenode *rightptr;
};
//////////////////////////////////////////////////////////1
class tree{
    public:
        tree();
        void insertnode(const int &);
        void preorder() const;
        void inorder() const;
        void postorder() const;
    private:
        treenode  *rootptr;
        void inserthelp(treenode**,const int &);
        void prehelp(treenode*)const;
        void inhelp(treenode* )const;
        void posthelp(treenode*)const;
};
//////////////////////////////////////////////////////////2
tree::tree(){rootptr=0;cout<<"drive"<<endl;}
//////////////////////////////////////////////////////////3
void tree::insertnode(const int &value){
    inserthelp(&rootptr,value);
}
/////////////////////////////////////////////////////////4
int h=0;
void tree::inserthelp(treenode**ptr,const int &value){
    //cout<<"st  " <<ptr<<"  "<<value<<endl;
    if(*ptr==0){//tree is empty
        *ptr=new treenode(value);
        //cout<<"pt  "<<ptr<<"  "<<value<<endl;
        assert(*ptr!=0);
    }
 
    else
        if(value<(*ptr)->data){//cout<<"lef   "<<(&((*ptr)->leftptr))<<endl;
        inserthelp(&((*ptr)->leftptr),value);}
        else
            if(value>(*ptr)->data){//cout<<"ri   "<<(&((*ptr)->rightptr))<<endl;
                inserthelp(&((*ptr)->rightptr),value);
 
            }
            else
                cout<<value<<"is duplicated"<<endl;
            //cout<<"h  "<<h<<endl;h++;
}
///////////////////////////////////////////////////////////5
void tree::preorder()const{
    prehelp(rootptr);
}
///////////////////////////////////////////////////////////6
void tree::prehelp(treenode* ptr)const{
    if(ptr!=0){
        cout<<ptr->data<<"  ";
        prehelp(ptr->leftptr);
        prehelp(ptr->rightptr);
    }
}
/////////////////////////////////////////////////////////7
void tree::inorder()const{
    inhelp(rootptr);
}
///////////////////////////////////////////////////////////8
void tree::inhelp(treenode *ptr)const{
    if(ptr!=0){
        inhelp(ptr->leftptr);
        cout<<ptr->data<<"  ";
        inhelp(ptr->rightptr);
 
    }
}
///////////////////////////////////////////////////////////9
void tree::postorder()const{
    posthelp(rootptr);
}
///////////////////////////////////////////////////////////10
void tree::posthelp(treenode *ptr)const{
    if(ptr!=0){
        posthelp(ptr->leftptr);
        posthelp(ptr->rightptr);
        cout<<ptr->data<<endl;
    }
}
///////////////////////////////////////////////////////////11
void main(){
 
    tree inttree;
    int intval;
    cout<<"enter 5 int";
        for(int i=0;i<6;i++)
        {
            cin>>intval;
            inttree.insertnode(intval);
        }
        cout<<"preo\n";
        inttree.preorder();
        cout<<"\ninorder\n";
        inttree.inorder();
        cout<<"\npostorder\n";
        inttree.postorder();
}

[abejary]

Actually, the task looked like sth like this:
Create a multiple inheritance to derive the below algebraic hierarchical computation: -given a vertical shaped networks over 3 node. Derive the lowest module single object and process the vertical hierarchical data.

I'm starting to think I may have perceived the task incorrectly; maybe, what it requires is not a multiple inheritance indeed.
I am so confused and do not know what to do.