我有以下C++设计问题，非常感谢任何建议/解决方案。
请注意，我的背景不是计算机科学，因此我可能缺少一些明显的解决方案。

我通常在代码中分离关键组件的方式是通过抽象类和纯虚函数定义接口(interface)。

范例1:

class B
{
public:
    virtual double f( double x ) = 0;
};

class D1 : public B
{
public:
    double f( double x ) const 
    {
    return 0.0;
    }
};    

class D2 : public B
{    
public:
    double f( double x ) const 
    {
    return 1.0;
    }
};

class F {
public:
    virtual double f( double x ) = 0;
};

class G {
public:
    virtual double g( double x ) = 0;
};

class H {
public:
    virtual double h( double x ) = 0;
};

class N {};

template<class T1, class T2=N, class T3=N>
class Feature : public T1 , public T2 , public T3
{
};

template<class T1, class T2>
class Feature<T1,T2,N> : public T1, public T2
{
};

template<class T1>
class Feature<T1,N,N> : public T1
{
};

//Supp for Supports/Implements
class SuppFandG : public Feature<F,G>
{
public:
    double f( double x ) { return 0.0; }
    double g( double x ) { return 1.0; } 
};

class SuppFandH : public Feature<F,H>
{
public:
    double f( double x ) { return 0.0; }
    double h( double x ) { return 1.0; } 
};

class SuppFandGandH : public Feature<F,G,H>
{
public:
    double f( double x ) { return 0.0; }
    double g( double x ) { return 1.0; }
    double h( double x ) { return 2.0; }
};

int main()
{
    Feature<F,G>* featureFandGPtr;
    Feature<F,H>* featureFandHPtr;
    Feature<H,F>* featureHandFPtr;
    Feature<F,G,H>* featureFandGandHPtr;

    SuppFandGandH suppFandGandH;
    featureFandGandHPtr = &suppFandGandH;

    //featureFandGPtr = featureFandGandHPtr; //Illegal. static_cast illegal too.
    //the reason to do this is that I would like to pass a pointer to an object 
    //of type Feature<F,G,H> to a function (or constructor) that expects a pointer to Feature<F,G> 
    featureFandGPtr = reinterpret_cast< Feature<F,G>* >( featureFandGandHPtr );
    featureFandHPtr = reinterpret_cast< Feature<F,H>* >( featureFandGandHPtr );
    featureHandFPtr = reinterpret_cast< Feature<H,F>* >( featureFandGandHPtr );

    featureFandGPtr->f( 1.0 );
    featureFandGandHPtr->h( 1.0 );
}

//This will not work, Visual studio 2008 professional crash.
template<class T1, class T2=N, class T3=N>
class Feature : public Feature<T1,T2> , public Feature<T1,T3> , public Feature<T2,T3>
{
};

template<class T1, class T2>
class Feature<T1,T2,N> : public Feature<T1>, public Feature<T2>
{
};

template<class T1>
class Feature<T1,N,N> : public T1
{
};

最佳答案

现在，这是一个有趣的问题!

显而易见的(简单)解决方案是使模板疯狂。如果每个功能仅需要一个接口(interface)(而不是一个确定的类型)，则可以减轻您的大部分顾虑。但是，当然这在依赖方面有其自身的惩罚，您在第4点中拒绝了该解决方案。

动态转换？

struct Feature { virtual ~Feature() {} };

class F: public Feature {};
class G: public Feature {};

class Impl: public F, public G {};

void method(Feature const& i)
{
  F const& myF = dynamic_cast<F const&>(i);
  G const& myG = dynamic_cast<G const&>(i);

  myF.f(2.0);
  myG.g(2.0);
}

namespace detail
{
  void methodImpl(F const& f, G const& g);
}

template <class T>
void method(T const& t)
{
  detail::methodImpl(t,t);
}

class F
{
public:
  void f(double d);
  void f2(double d, double e) const;
};

class FForwarder
{
public:
  FForwarder(F& f) : m_object(f) {}

  void f(double d) { m_object.f(d); }
  void f2(double d, double e) const { m_object.f(d,e); }

private:
  F& m_object;
};

struct nil {};

template <class Head, class Tail>
struct Aggregator: Head, Aggregator<Tail::head, Tail::tail>
{
  typedef Head head;
  typedef Tail tail;

  template <class T>
  Aggregator(T& t) : Head(t), Aggregator<Tail::head, Tail::tail>(t) {}
};

template <class Head>
struct Aggregator<Head,nil> : Head
{
  typedef Head head;
  typedef nil tail;

  template <class T>
  Aggregator(T& t) : Head(t) {}
};

template <>
struct Aggregator<nil,nil>
{
  typedef nil head;
  typedef nil tail;

  template <class T>
  Aggregator(T&) {}
};

int method(Aggregator<FForwarder, Aggregator<GForwarder, HForwarder> >& fgh);

namespace detail
{
  typedef Aggregator<FForwarder, Aggregator<GForwarder, HForwarder> > methodImplArg;
  int methodImpl(methodImplArg& arg);
}

template <class T>
int method(T& t)
{
  detail::methodImplArg arg = detail::methodImplArg(t);
    //named temporary because it is passed by reference to non-const

  return detail::methodImpl(arg);
    // forward the result as well
};

关于c++ - 如何为任意(但在编译时定义)功能支持定义抽象基类？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1723796/