Changing member types in inheritance

3
votes

Given a base class Base that has two derived classes, DerA and DerB, can the derived classes have a member variable that is used in a Base member function, but is a different type for each class?

class Base {
    * a // Declare a as *something*, so it can be used by "doWork"

    template <typedef T>
    void doWork(T b) { // Add another value to "a" which is of its same type
        a += b; // For example; an operation that works on "a", no matter what numeric type it is
    }
}

class DerA : public Base {
    // Make "a" an int
}

class DerB : public Base {
    // Make "a" a float
}

In practice, a will be a base struct, while DerA and DerB will have derived versions of the base struct (derivative classes will each have a derived form of the struct specific to their purpose, but each must do a simple operation on a, so it seems pointless to copy/paste that simple function for each derivative when I can just use a template function). I would just type a as the base struct type, but then I lose access to the various specialized member functions and variables that each derived struct has (if I understand inheritance correctly).

I apologize if this question is a repeat, but I don't know what this quality would be called, so Googling proved fruitless.

3
c++templatesinheritance
As it is, I cannot see why is shouldnt be template <typename T> class Der { T t; template <typename K> void doWork(K b) { a+=b;}}; typedef Der<int> DerA; typedef Der<float> DerB;} - IdeaHat
A better way to say my previous comment, why are you bothering with polymorphism in this case? this seems like a cut and dry application for a template class. - IdeaHat
Do you need to pass DerA*s and DerB*s around as Base*s? I hope not. - Yakk - Adam Nevraumont
@MadScienceDreams, in practice, the classes are much more complex than shown. Forgive my lack of explanation. You're right, templating the entire class would be useful, but I don't want to template each one if I can avoid it, especially because this is just one small function of the class. - sgbrown
@sgbrown That's fine. Just a quick hint: the CRTP still uses a templated base class, so if you're trying to provide an interface, you'll need to but an iBase non-templated interface class, and have Base inherit from it. - IdeaHat

3 Answers

3
votes

What you might want is the CRTP.

template<class D>
struct Base {
  D* self() { return static_cast<D*>(this); }
  D const* self() const { return static_cast<D*>(this); }
  template<class T>
  void doWork(T b) {
    self()->a += b;
  }
};
struct DerA : public Base<DerA> {
  int a;
};
struct DerB : public Base<DerB> {
  double a;
};

Here we pass the derived type to our base class. Within the base class, you can use self()-> to access fields in the derived type. This allows basically full access to the derived type, while letting us share code in the base class.

Note that you cannot pass DerA and DerB around as a Base this way. If you want that, you need a virtual method doWork, and virtual template methods don't exist.

CRTP stands for the curiously repeating template pattern, which I imagine is named because it is strange, it involves repeating a type, and it keeps on showing up in strange corners as being useful.

Type erasure probably won't work either, as you want to dispatch the type erasure from two different spots in the code base (the double dispatch problem: you need a centralized list of types supported to do the type Cartesian product on).

To expand on that, in order to support a+=b where both a and b are arbitrary types, you would have to expand over all types twice over, including types that are never mutually visible at the same spot in a compilation unit. That isn't possible.

If you need a common base, and there are only some types you pass to doWork, here is how you do it:

struct Base {
  virtual void doWork( double ) = 0;
  virtual void doWork( int ) = 0;
  virtual void doWork( long long ) = 0;
};

template<class D>
struct Base_helper:Base {
  D* self() { return static_cast<D*>(this); }
  D const* self() const { return static_cast<D*>(this); }
  template<class T>
  void doWork_impl(T b) {
    self()->a += b;
  }
  void doWork( double x ) override { doWork_impl(x); };
  void doWork( int x ) override { doWork_impl(x); };
  void doWork( long long x ) override { doWork_impl(x); };
};
struct DerA : public Base_helper<DerA> {
  int a;
};
struct DerB : public Base_helper<DerB> {
  double a;
};

note that every version of doWork must be valid to call on each of the Ders, as the Base_helper instantiates all of them.

If the kind of type passed to doWork is unbounded, yet the types of Der is bounded, you can do something like the above only backwards. It gets awkward, however. Your best bet in that kind of situation is to use a boost::variant type solution.

2
votes

I guess you want to achieve something like this:

template<typedef T>
class Base {
    T a;
    void doWork(T b) { // Add another value to "a" which is of its same type
        a += b; // For example; an operation that works on "a", no matter what numeric type it is
    }
}

class DerA : public Base<int> {
}

class DerB : public Base<float> {
}

Or you can dump classes DerA and DerB entirely and use typedefs instead:

typedef Base<int> DerA;
typedef Base<float> DerB;
2
votes

This can be easily solved with a CRTP-like pattern:

template<class D> // Base class is templated
class Base {
public:
    D a;
    void doWork(D b) {
        a += b;
    }
};

class DerA : public Base<int> {};

class DerB : public Base<float> {};

Live Example

Edit: in case you need only one common base (Base<int> is a completely different type from Base<float>) you might use an interface class and have Base inherit from it.