Detecting if we are in child class or base class

Question

I have a problem, and I tried to use RTTI to resolve it.

I have a class Base and children classes (in the example, I show only one Child)

class Base {
    virtual void Eval() {

      // normal treatment
              +
      // treatment only for Base instance
    }
};

class Child : Base {
    void Eval() {
      // call Base Eval
      Base::Eval();
      //other treatment
    }
};

The problem, is that in Base::Eval, there are some treatments which I dont't want to execute when I call it from Child. What I mean, in Child::Eval, when we call the Base::Eval, we want only the normal treatment which is executed.

For this, I thought about RTTI. I don't know if it is the best way to use it, I thought to do something like this:

class Base {
        virtual void Eval() {

          // normal treatment
                  +
          if (typeid(this).name() == typeid(Base).name()) {         
            // treatment only for Base instance
          }
        }
    }

The question is: Is it permitted to do that? Am I obliged to check typeid.name()? Or would just typeid() be enough?

Answer 1

Situations such as this are almost always an indication of bad design. A base class should not know anything about its derived classes.

If you want to give derived classes an option to customise parts of the base behaviour, use virtual functions and the "template method" design pattern:

class Base
{
public:
  virtual void Eval() {
    // normal treatment
    Eval_CustomisationHook();
  }

protected:
  virtual void Eval_CustomisationHook()
  {
    // Do the stuff
  }
};

class Child : public Base
{
protected:
  virtual void Eval_CustomisationHook()
  {} // do nothing
};

Alternatively, you could delegate just the query:

class Base
{
public:
  virtual void Eval() {
    // normal treatment
    if (doOptionalEvalPart()) {
      // do it here
    }
  }

protected:
  virtual bool doOptionalEvalPart()
  {
    return true;
  }
};

class Child : public Base
{
protected:
  virtual bool doOptionalEvalPart()
  {
    return false;
  }
};

---

And to answer your original question as well: the correct form would be to compare the std::type_info objects, not their names. And don't forget you'd have to dereference this. So the code would look like this:

if (typeid(*this) == typeid(Base))

This will do what you want it to. But as I've said above, this is most probably not the proper approach.