假设我想编写一个 C++ 函数,它的参数是一个符合两个不相关接口(interface)的对象。有几种方法可以做到这一点;我在下面列出了三个以及我的批评。 (在我回答实际问题之前请耐心等待)。
1) 作为模板函数
template<typename T> void foo(const T& x) {
x.fromInterfaceA();
x.fromInterfaceB();
}
这可能是最好的“标准”解决方案,但要确保 x
真正继承自 A
和 B
需要额外的 static_assert
s、type_traits
等,笨拙且啰嗦。此外,用户被迫不断编写模板代码,而实际上并不需要真正通用的行为。
2) 通过让函数接受特定的派生类
struct A {
// ...
virtual void fromInterfaceA() = 0;
};
struct B {
// ...
virtual void fromInterfaceB() = 0;
};
struct AB : public A, public B {};
void foo(const AB& ab) {}
我们被迫创建一个新类来表达其他两个类的组合,更糟糕的是,foo()
无法接受可能继承自 A 的参数
和 B
通过不同的路线,例如通过中级类。我们很快就会陷入分类噩梦,那里有多个微接口(interface)。
3) 通过让 foo
为每种类型接受一个单独的参数,并多次传递该对象。
void foo(const A& xAsA, const B& xAsB) {}
int main() {AB ab; foo(ab, ab);}
这是最灵活的解决方案(因为它也很适合继承之上的组合方法),但它也令人困惑,掩盖了 foo
应该在单个对象,并允许 foo
接受两个单独的对象,这可能导致病态行为。
在 Haskell 中,我们可以按照我所说的方式组合类型约束。如果 C++ 中存在允许同样事情的语法,那就太好了;不过,我可以看出,这会对类机制的内部结构产生严重影响。我们可以编写一个模板类,类似于这个粗略的草图:
template<typename T1, typename T2> class Composition
{
public:
template<typename T> Composition(T& t) : t1_(t), t2_(t) {}
operator T1&() {return t1_;}
operator T2&() {return t2_;}
template<typename T> T& as() {return operator T&();}
private:
T1& t1_;
T2& t2_;
};
这似乎提供了模板解决方案 (1) 的优势,同时隔离了实际的模板代码。
我的问题是:是否有任何标准设计模式可以处理这个问题?或者,是否有一个范例可以解决问题,同时仍然允许我所说的相同类型的灵 active ?我也对关于上述讨论的更一般性的批评或想法感兴趣。
最佳答案
在您的第一个示例中,只需将参数转换为两种类型就足够了。
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; }
}
这将允许您稍后对某些类型使用组合而不是继承。
此外,现在将此申请用于超过三种类型对我来说并不那么麻烦......因为组合或委托(delegate)等是可能的。
关于c++ - 在 C++ 中组合接口(interface),我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/33427561/