0

我正在使用策略模式和抽象工厂模式在运行时在计算器类中生成不同的算法。

计算将取决于所涉及类型之间的关系。这就是为什么我将“*Algorithm::calculate”作为一个成员函数模板，对于关系而言是通用的。

但是，我已经有一个在现有代码中完全基于实现的算法，它既不是通用的也不是基于迭代器的，我想将它添加到算法层次结构中，以便我也可以使用 AbstractFactory 生成它看看它的行为。

基于实现的算法使用计算中涉及的类型的成员函数来完成计算。在这个例子中，它将使用RelationshipWithA::target_type 成员函数来访问Type& 的数据，以及使用“A”成员函数来访问RelationshipWithA::a_ 的数据。

这是我到目前为止想出的（这只是一个模型，没有抽象工厂和计算器类）：

#include <iostream>

class Result{}; 

class A {};  

class B {
    public: 
        void specific() const 
        { 
            std::cout << "B::specific()" << std::endl;
        };
};

class C : public B {};

class D {};

template<class Type>
class RelationshipWithA
{
    const A& a_; 

    const Type& t_;

    public: 
        typedef Type target_type; 

        RelationshipWithA (const A& a, const Type& t)
            :
                a_(a), 
                t_(t)

        {
            std::cout << "RelationshipWithA::ctor" << std::endl;
        }; 

        const A& a() const 
        {
            return a_; 
        }

        const Type& type() const
        {
            return t_;
        }
};

class DefaultAlgorithm 
{
    public:
        template <class Relationship>
        void calculate (Result& res, const Relationship& r)
        {
            std::cout << "DefaultAlgorithm::calculate" << std::endl;
            const A& a = r.a(); 
            const typename Relationship::target_type& t = r.type(); 
            // Default iterator based calculation on a, target_type and r
        };
};

class AlternativeAlgorithm 
: 
    public DefaultAlgorithm 
{
    public:
        template <class Relationship>
        void calculate (Result& res, const Relationship& r)
        {
            std::cout << "AlternativeAlgorithm::calculate" << std::endl;
            // Optimized iterator based calculation on a, target_type and r
        }
};

class ImplementationBasedAlgorithm 
:
    public DefaultAlgorithm 
{
    public:
        // No specialization: Relationships store
        // a const reference to any class that inherits from B
        template <class Relationship>
        void calculate (Result& res, const Relationship& r)
        {
            // Use B implementation and the Relationship With  A to compute the result
            std::cout << "ImplementationBasedAlgorithm::calculate" << std::endl;
            const A& a = r.a(); 
            const B& b = r.type();
            b.specific();
            // Implementation based on B implementation
        }
};

int main(int argc, const char *argv[])
{
    Result res; 

    A a; 
    C c; 

    RelationshipWithA<C> relationshipAC (a, c);

    DefaultAlgorithm defaultAlg; 
    AlternativeAlgorithm alternativeAlg;
    ImplementationBasedAlgorithm implementationAlg;

    defaultAlg.calculate(res, relationshipAC);
    alternativeAlg.calculate(res, relationshipAC);
    implementationAlg.calculate(res,relationshipAC);

    D d; 
    RelationshipWithA<D> relationshipAD (a, d);

    defaultAlg.calculate(res, relationshipAD);
    alternativeAlg.calculate(res, relationshipAD);
    // This fails, as expected
    //implementationAlg.calculate(res,relationshipAD);

    return 0;
}

我喜欢这种设计，因为算法不是通用类，这使得通用抽象工厂在运行时很容易生成它们。

然而，在 Effective C++ 中有一个 Item 36 说：“永远不要重新定义继承的非虚拟函数”。我的意思是，非虚拟函数是实现不变的，它们通常不应该被覆盖，但是：

  1. C++ 中没有可用的虚拟成员函数模板。
  2. 如果我在RelationshipWithA 和“*Algorithm::calculate”上将Algorithm 类设为通用成员函数，则工厂需要了解Realtionship 才能生成算法，并且代码会变得很臭（至少对我而言）。

即使我覆盖了继承的非虚拟函数（函数模板），这是否是该问题的正确解决方案？

对客户来说，行为上没有任何区别：结果就在那里，唯一的区别在于计算的方式。这意味着仍然维持 Is-A 关系：“*Algorithm::calculate”对于客户端仍然是实现不变的。

4

1 回答 1

1

这不是真正的Is-A关系...

具体实现并不是真正的 DefaultAlgorithm ...它们是特定算法...

您可以有一个可以使用工厂创建的空BaseAlgorithm类。但是，在使用模板函数之前，无论如何您都需要将其转换为正确的类型。无论如何，这有点击败工厂模式，因为您没有使用接口。

在您的情况下，如果工厂创建派生类之一但返回基类，如果您使用该变量，它将调用基类方法：

DefaultAlgorithm algo = Factory.CreateImplementationBasedAlgorithm();
RelationshipWithA<D> relationshipAD (a, d);
algo.calculate(res, relationshipAD); //won't fail because the base class methods are used (because it isn't virtual)

要解决这个问题，您可以创建一个基Relationship类，并将calculate()方法设为虚拟。calculate()
方法 将获得然后您可以将关系静态转换为具有该算法所需的接口的某个 base_relationship 接口，因此您可以因没有正确的 a()或type()方法而导致编译失败。

于 2013-03-02T13:35:47.810 回答