Question

A scene like this:
I’ve different of objects do the similar operation as respective func() implements.
There’re 2 kinds of solution for func_manager() to call func() according to different objects

Solution 1: Use virtual function character specified in c++. func_manager works differently accroding to different object point pass in.

class Object{
  virtual void func() = 0;
}
class Object_A : public Object{
  void func() {};
}
class Object_B : public Object{
  void func() {};
}
void func_manager(Object* a)
{
   a->func();
}

Solution 2: Use plain switch/case. func_manager works differently accroding to different type pass in

typedef enum _type_t
{
  TYPE_A,
  TYPE_B
}type_t;

void func_by_a()
{
// do as func() in Object_A
}
void func_by_b()
{
// do as func() in Object_A
}
void func_manager(type_t type)
{
    switch(type){
        case TYPE_A:
            func_by_a();
            break;
        case TYPE_B:
            func_by_b();
        default:
            break;
    }
}

My Question are 2:
1. at the view point of DESIGN PATTERN, which one is better?
2. at the view point of RUNTIME EFFCIENCE, which one is better? Especailly as the kinds of Object increases, may be up to 10-15 total, which one’s overhead oversteps the other? I don’t know how switch/case implements innerly, just a bunch of if/else?

Thanks very much!

Answer 1

from the view point of DESIGN PATTERN, which one is better?

Using polymorphism (Solution 1) is better.
Just one data point: Imagine you have a huge system built around either of the two and then suddenly comes the requirement to add another type. With solution one, you add one derived class, make sure it’s instantiated where required, and you’re done. With solution 2 you have thousands of switch statements smeared all over the system and it is more or less impossible to guarantee you found all the places where you have to modify them for the new type.

from the view point of RUNTIME EFFCIENCE, which one is better? Especailly as the kinds of Object

That’s hard to say.
I remember a footnote in Stanley Lippmann’s Inside the C++ Object Model, where he says that studies have shown that virtual functions might have a small advantage against switches over types. I would be hard-pressed, however, to cite chapter and verse, and, IIRC, the advantage didn’t seem big enough to make the decision dependent on it.