使用第1层指针调用第3层子类

Question

I made a class hierarchy where the 1st layer super class is staff. In my 2nd layer I have 2 subclasses called admin staff and academic staff. (These two layers are also abstract classes). Academic staff have 2 more subclasses teaching only and research only.

In my main, am trying to create an array of 10 staff pointers(5 of admin and 5 of academic) and manipulate 3rd layer subclasses using the pointers. Bare in mind the 3rd layer subclasses have behaviors which are not present in the in 1st or 2nd layer. Hence, I have to use type casting. I can change my 3rd layer behavior individually like eg,

((ResearchStaff *)ptr[i])->setResearchHour(23);

but it gets very messy very quickly. My question, how can i access my 3rd layer behaviors in a for or while loop without having to individually set them. Heres the main that im working with. Thanks A LOT!!

int main()
{
  Staff *ptr[10];
  for(int i=0;i<10;i++)
  {
    ptr[i] = new AdminStaff;
    ((AdminStaff *)ptr[i])->setAdmin(12);

    i++;
    ptr[i] = new TeachingStaff;
    (( TeachingStaff*)ptr[i])->setTeaching(16);
  }
}

Answer 1

Two things!

1. When you create a new derived class object, in this case AdminStaff or TeachingStaff , you don't have to typecast back to base to invoke a derived class method.

So instead of,

    ptr[i] = new TeachingStaff;
    (( TeachingStaff*)ptr[i])->setTeaching(16);

you can write something like,

    TeachingStaff *ts = ptr[i] = new TeachingStaff;
    ts->setTeaching(16);

2. You should only call the base class reference/ pointer to invoke methods which are common to all the classes.

Finally, if these classes do not have many attributes in common you can consider composition as an alternate design strategy instead of using multiple inheritance.

Answer 2

You could use the Visitor pattern.

Add a method to your Staff class called accept , like this:

class Staff 
{
   //Other staff stuff
   public:
      void accept(const Visitor& v) = 0;
}

Add implementations to your leaf classes...

class ResearchTeacher
{
    //Other research teacher stuff...

    public:
       void accept(const Visitor& v) {
       v.visit(*this);
    }
}

Then define a Visitor that knows what to do with each type:

class Visitor
{
   public:
      void visit(ResearchTeacher& teacher) 
      {
         teacher.setResearch(16);
      }

      void visit(TeachingTeacher& teacher)
      {
         teacher.setTeaching(16);
      }

      void visit(AdminStaff& admin) 
      {
         admin.setAdmin(12);
      }
}

Now the calling code doesn't have to worry about it:

int main()
{
  Visitor v;
  Staff *ptr[10];
  for(int i=0;i<10;i++)
  {
    ptr[i] = new AdminStaff;
    ptr[i]->accept(v);

    i++;
    ptr[i] = new TeachingStaff;
    ptr[i]->accept(v);
  }
}