Dynamic Inheritence using Templates

Can someone please tell me if this sort of thing is possible:

I have three classes, A, B, C. and I have a fourth, class D, that inherits any one of A, B or C. Is it possible to dynamically pick which one to inherit from without using the strategy (or bridge) patterns:

For example:

Code:

---


template <class T = someCondition ? A : B> class D;

class C {...};
class B {...};
class A {...};

template <class T>
class D : public T
{
...
};

---

Then later, dynamically have the base class chosen for me by setting what the someCondition variable is set to.

Code:

---


A<> i;

---

Is this sort of thing possible? Or is there a better way of auto-picking the base class of a template WITHOUT manually specifying the template parameters?

Do you have any concrete examples for the four classes? It does sound like a design pattern will be appropriate instead of trying some C++ template magic.

You can't do anything dynamic with templates, but with compile time constants what you said could be made to work.

What are you trying to do specifically?

Here's a use case. Suppose you have a compile-time-sized buffer class:

Code:

---

template <typename E, size_t Size>
class buffer;

---

Suppose further you want this buffer to be in the class if it is smaller than some threshold, but dynamically allocated if it's larger. (That's because the primary use for the buffer is to be on the stack, but space is limited.)

Code:

---

const size_t THRESHOLD = 1024 * 16; // 16k

---

Here's one way to do it at zero runtime cost.

Code:

---

#include <stddef>

#include <boost/scoped_array.hpp>
#include <boost/mpl/if.hpp>

using std::size_t;

namespace detail
{
  template <typename E, size_t Size>
  class direct_holder
  {
    E m_data[Size];
  public:
    E *ptr() { return m_data; }
    E const *ptr() const { return m_data; }
  };

  template <typename E, size_t Size>
  class heap_holder
  {
    boost::scoped_array<E> m_data;
  public:
    heap_holder() : m_data(new E[Size]) {}
    E *ptr() { return m_data.get(); }
    E const *ptr() const { return m_data.get(); }
  };
}

template <typename E, size_t Size>
class buffer :
  private boost::mpl::if_c<
    Size < THRESHOLD,
    direct_holder<E, Size>,
    heap_holder<E, Size>
  >::type
{
  // Don't forget to use this->ptr()
};

---

Of course, if memory serves, that's exactly the strategy pattern, but with automatic strategy selection.

Very interesting. My concrete example is using a few specialized classes for SIMD. Some are SSE, 3DNow, etc.

The only reason why I did not use a straight up stategy pattern was because of the extra overhead. I'm aiming for the shortest path possible so that its really fast. But if there is no way around it, This boost method might be nice.

Thanks.

There ought to be no runtime overhead in the template strategy pattern.

By the way, if you don't want all of Boost just for mpl::if_c, here's a simple implementation. It doesn't have all the workarounds for broken compilers that mpl::if_c has, tough. It will not, for example, work on VC++6.

Code:

---

template <bool Cond, typename ThenType, typename ElseType>
struct if_c { typedef ElseType type; };

template <typename ThenType, typename ElseType>
struct if_c<true, ThenType, ElseType> { typedef ThenType type; };

---

That works fine and dandy if I manualy hard code the template Type. If I try to dynamically input a bool into Cond, it doesnt compile:

Code:

---

bool a = false;

// This doenst compile
if_c<a, classOne, classTwo> i;

---

That's because templates are a compile time mechanism. You can't use them to solve runtime problems. (You can use them to refactor runtime problems, but that's a whole different can of worms.)

Dang, there goes my hope for on the fly dynamic inheritance.
O well.

Surely, what you want is something like this:

Code:

---

class Base {
  ...
public:
  virtual calculatesomething() = 0;
  ....
};


class CSSE : public Base
{
  virtual calculatesomething();
}

CSSE::calculatesomething() {
  ... SSE code ...
}

class C3DNow: public Base
{
  virtual calculatesomething();
}

C3DNow::calculatesomething() {
  ... 3DNow code ...
}


class CGeneric: public Base
{
  virtual calculatesomething();
}

CGeneric::calculatesomething()
{
    .... Use standard C library to perform the math ...
}

Base *pClass;

int main()
{
    int x;
    x = bestMath();
    switch(x)
    {
      case M_SSE:
          pClass = new CSSE;
          break;
      case M_3DNow:
          pClass = new CSSE;
          break;
      default:
          pClass = new CGeneric;
    }
    pClass->calculateSomething;
}

---

--
Mats

matsp, Yes Thats what I am going to implement now. Or at least something similar.
Thanks for the insight tho.