Question

Suppose I have this base class:

struct Vehicle {
  //"op" stands for the operator of the vehicle
  //examples: pilot, truck driver, etc.
  virtual void insert_op(Op op) = 0;
  //other members...
};

And these two subclasses

struct Truck : public Vehicle {
  void insert_op(Op op) override {
    //prepare Truck with truck driver
  }
};

struct Airplaine : public Vehicle {
  void insert_op(Op op) override {
    //prepare Airplaine with pilot
  }
};

As you guess, this is the other hierarchy:

struct Op {};
struct TruckDriver : public Op {};
struct Pilot : public Op {};

You already see the problem, don’t you? I want to FORCE Truck to accept only TruckDrivers and FORCE airplaines to accept only Pilots, but this is not possible in the current design. C++ does not allow diff parameters for overridden virtuals.

I guess I could do a run-time type check of the type of “Op” in each of the subclass implementations of insert_op, but that sounds like a really ugly solution, plus its not enforced at compile time.

Any ways out?

Answer 1

Your Vehicle says virtual void insert_op(Op op) which means “every vehicle can accept any Op“.

Therefore, according to your design, a Truck isn’t a valid candidate for a Vehicle subclass because it can’t accept any Op – it can accept only TruckDrivers.

Related: Liskov substitution principle

---

The problem is in your design, not in implementation of it. I suggest to simplify your class hierarchy. Do you really need so many classes and inheritance? Can you simply go with Vehicle and Op that have fields identifying their type?

---

Let me further explain the design problem:

Assume some object A with a method manVehicle(Vehicle&). Truck is a subclass of Vehicle, so it’s possible to call this method with an object of type Truck.

However, the implementation of A doesn’t have a clue what concrete types of Vehicles. It only knows that all vehicles have a method insert_op(Op), so it’s valid for it to attempt a call like insert_op(Pilot()) even if the vehicle is actually a Truck.

Conclusions:

• Compile-time check isn’t even possible

• Runtime check could work…

  • but would only sweep the problem under the rug. An user of Vehicles expects to be able to call insert_op(Op) on any Vehicle.

A solution would be to modify the Vehicle interface to look like:

struct Vehicle {
  virtual bool can_insert_op(Op op) = 0;
  virtual void insert_op(Op op) = 0;
};

and document it so that the caller would know that insert_op can be only called with Ops that satisfy can_insert_op on the given Vehicle. Or something analogous (like a documented exception from insert_op “invalid op type for this vehicle”) – anything works as long as it’s a documented part of this interface.

---

BTW technical remark: You’d probably want these methods to take the Op by pointer or reference instead of copying it, to avoid an unnecessary copy as well as slicing.