通过组合添加类功能

Question

假设我们有一个抽象类 Element，Triangle 和 Quadriside 类是从该抽象类派生出来的。

假设这些类与依赖于元素形状的插值方法结合使用。因此，基本上我们创建了一个抽象类 InterpolationElement，从中派生出 InterpolationTriangle 和 InterpolationQuadriterior。

然后，为了在 Triangle 和 Quadriside 类中包含插值功能，我们在 Element 类型的类 Element 中添加一个常量引用数据成员>InterpolationElement，即：

class Element
{
public:
    Element(const InterpolationElement& interp);

    const InterpolationElement& getInterpolation() const;

private:
    const InterpolationElement& interpolation;
};

然后我们创建一个方法（如 Scott Meyers，Effective C++ 中所述），将 InterpolationTriangle 类的本地静态对象实例化为

const InterpolationTriangle& getInterpolationTriangle()
{
    static InterpolationTriangle interpolationTriangle;

    return interpolationTriangle;
}

该类 Triangle< /code> 可以这样构造：

class Triangle : public Element
{
public:
    Triangle() : Element( getInterpolationTriangle() ) {}
};

这是我的问题：为了在我的类 Element 上合并插值方法，这种方法是否正确？这是在专业场景中使用的吗？

我可以直接在 Element 类（作为纯虚拟）上实现所有插值方法，并在派生类 Triangle 和 Quadriside 中覆盖它们。然而，在我看来，这种方法很麻烦，因为每次我需要改进或实现新的插值功能时，我都必须在这些类上执行此操作。此外，使用这种方法，类会变得越来越大（有很多方法）。

我想听听您的一些提示和意见，

提前致谢。

---

其他详细信息：

class InterpolationElement
{
public:
    InterpolationElement();

    virtual double interpolationMethod1(...) = 0;
                      :
    virtual double interpolationMethodN(...) = 0;
}

class InterpolationTriangle : public InterpolationElement
{
public:
    InterpolationTriangle () {}

    virtual double interpolationMethod1(...) { // interpolation for triangle }
                      :
    virtual double interpolationMethodN(...) { // interpolation for triangle }
}

class InterpolationQuadrilateral : public InterpolationElement
{
public:
    InterpolationTriangle () {}

    virtual double interpolationMethod1(...) { // interpolation for quadrilateral}
                      :
    virtual double interpolationMethod1(...) { // interpolation for quadrilateral}
}

Answer 1

这些类与插值方法结合使用。为什么这些方法需要位于单例对象中？这里的单例看起来很有问题。

class Element
{
public:
    virtual double interpolationMethod1(...) = 0;
                  :
    virtual double interpolationMethodN(...) = 0;

};

class Triangle : public Element
{
public:
    virtual double interpolationMethod1(...) { // interpolation for triangle }
                  :
    virtual double interpolationMethodN(...) { // interpolation for triangle }
}

另外，欢迎来到SO！

Answer 2

这让人想起我回答过的一个问题 在这里。关于数据容器和策略分离的想法相同。

Answer 3

您的提案有一个小问题：您在基类中添加了一个与插值相关的方法，并且更改了构造函数...

所以首先，如果您希望这样做，那么您应该这样做it：

class Element
{
public:

private:
  // similar signature to a `clone` method
  virtual InterpolationElement* interpolation() const = 0;
};

class Triangle
{
public:

private:
  virtual InterpolationTriangle* interpolation() const
  {
    return new InterpolationTriangle();
  }
};

这里有 2 个优点：

• 不再需要更改每个派生对象的构造函数
• 策略对象不再是 const，这允许它在计算过程中维护状态...就像对当前正在插值的对象的引用。

但是，这仍然需要更改 Element 类及其每个派生类。这不打扰你吗;)？

好吧，是时候（这一次）调用设计模式了：Visitor。

和策略思路有点不一样，依靠双重调度才能正常工作。但是，它允许您一次性调整 Element 的层次结构（使用 accept 方法），然后添加任意数量的操作。那太好了。

Answer 4

您总是可能会弄乱模板。
首先我们有一个顶级班级。

class Element {
    public:
        virtual void calculate() const = 0;
};

...但是我们在层次结构的中间还有一个类，它实际上是一个模板。模板不能是顶级类，因为具有不同参数的模板是不同的类。我们的想法是，我们将插值类作为元素的类型参数。

template <typename Interpolation>
class Element_Impl : public Element {
    protected:
        Interpolation m_interpolation;
};

和插值类。请注意，他们不是兄弟姐妹，因为他们不需要。

class InterpolationTriangle {
    public:
        double interpolate(double a, double b) const {
            std::cout << "interpolation triangle" << std::endl;
        }
};
class InterpolationQuadrilateral {
    public:
        double interpolate(double a, double b) const {
            std::cout << "interpolation quadrilateral" << std::endl;
        }
};

最后是真正的元素和小主要程序。

class Triangle : public Element_Impl<InterpolationTriangle> {
    public:
        void calculate() const {
            m_interpolation.interpolate(1.0, 2.0);
        }
};
class Quadrilateral : public Element_Impl<InterpolationQuadrilateral> {
    public:
        void calculate() const {
            m_interpolation.interpolate(2.0, 3.0);
        }
};
int main() {
    const Element &a = Triangle();
    const Element &b = Quadrilateral();
    a.calculate();
    b.calculate();
}

摘要：

• 如果需要，您可以轻松切换每个元素的插值类。
• 没有像 Matthieu 的示例中那样的双重 vtable 访问（首先用于 Element 的计算，然后用于 InterpolationElement 的 intepolate 方法）。每个元素在编译时都知道它正在使用哪个插值类。
• Element_Impl 是一个丑陋的地方，但它使我们免于复制粘贴。您可以通过实现插值方法包装器来进一步扩展它
• http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern一种

方法是使用静态方法，并在 Element_Impl 中定义包装器 - 仍然只在一个地方。

class Element {
    public:
        virtual void calculate() const = 0;
};

template <typename Interpolation>
class Element_Impl : public Element {
    protected:
        void interpolate(double, double) const {
            Interpolation::interpolate(1, 1);
        }
};

class InterpolationTriangle {
    public:
        static double interpolate(double a, double b) {
            std::cout << "interpolation triangle" << std::endl;
        }
};

class InterpolationQuadrilateral {
    public:
        static double interpolate(double a, double b) {
            std::cout << "interpolation quadrilateral" << std::endl;
        }
};

class Triangle : public Element_Impl<InterpolationTriangle> {
    public:
         void calculate() const {
            interpolate(1.0, 2.0);
        }
};

class Quadrilateral : public Element_Impl<InterpolationQuadrilateral> {
    public:
        void calculate() const {
            interpolate(2.0, 3.0);
        }
};

int main() {
    const Element &a = Triangle();
    const Element &b = Quadrilateral();

    a.calculate();
    b.calculate();
}

Answer 5

我首先想到的是 GoF 设计模式访问者

根据我对你的问题的理解，这种模式正是为了解决这个问题而设计的。

每个访问者对象都定义了一种插值技术或应用于您的对象的算法。

因此，Element 类根本不会随着每个新功能而增长。一旦到位，访问者模式就可以丰富功能，而无需触及基类定义。