Question

假设我希望编写一个C ++函数，该函数将一个符合两个不相关接口的对象作为其参数。有几种方法可以做到;我列出了下面的三个以及我的批评。（在我得到实际问题之前，请耐心等待。）

1）作为模板功能

template<typename T> void foo(const T& x) {
    x.fromInterfaceA();
    x.fromInterfaceB();
}

这可能是“标准”解决方案中最好的解决方案，但确保x真正继承自A和B需要额外的static_assert s，{{1}等等，这是笨拙和冗长的。此外，用户被迫不断编写模板代码，实际上并没有真正的通用行为。

2）让函数接受特定的派生类

type_traits

我们被迫创建一个新类只是为了表达其他两个类的组合，更糟糕的是，struct A { // ... virtual void fromInterfaceA() = 0; }; struct B { // ... virtual void fromInterfaceB() = 0; }; struct AB : public A, public B {}; void foo(const AB& ab) {}无法接受可能继承自foo()和{{1}的参数通过不同的路线，例如通过中级课程。我们很快就会发生分类噩梦，那里有多个微接口。

3）让A为每种类型接受一个单独的参数，并多次传递该对象。

这是最灵活的解决方案（因为它也适用于继承组合方法），但它也令人困惑，模糊了foo应该在单个对象上运行的事实，并允许void foo(const A& xAsA, const B& xAsB) {} int main() {AB ab; foo(ab, ab);}接受两个单独的对象，可能导致病态行为。

在Haskell中，我们可以按照我所说的方式编写类型约束。如果C ++中存在允许相同内容的语法，那就太好了;但我可以看到，这会对类机制的内部产生严重影响。我们可以写一个模板类，就像这个粗略的草图：

foo

似乎提供了模板解决方案的优势，（1），同时隔离了实际的模板代码。

我的问题是：是否有任何标准设计模式可以解决这个问题？或者，是否存在问题消失的范例，同时仍然允许我所说的同样的灵活性？我也对上面讨论的更一般的批评或想法感兴趣。

Answer 1

在你的第一个例子中，将参数转换为两种类型就足够了。

template<typename T> void foo(const T& x) {
    const A* asA = &x;
    const B* asB = &x;
    // .. now use them ..
}

如果T不是从A和B派生的，那么这将产生编译错误。不需要特征或编译时断言。

这样做的一个有趣的好处是它可以很好地扩展到3种或更多类型。（虽然需要这可能是你设计中出现问题的一个迹象）。

如果您真的想要更多可自定义算法，我会考虑

template<typename T> void foo(const T& x) {
  const A* asA = FooTraits<T>::asA(x);
  const B* asB = FooTraits<T>::asB(x);
  ...
}

，默认为

template<typename T> class FooTraits<T> {
public:
   static const A* asA(const T& x) { return &x; }
   static const B* asB(const T& x) { return &x; }
}

然后允许您稍后为某些类型使用合成而不是继承。

此外，现在申请三种以上的类型对我来说并不感到苛刻..因为组合或授权等是可能的。

用C ++编写接口

1 个答案: