c++ - 工厂方法设计模式和桥接模式有什么区别？

Question

大家好，

谁能解释一下工厂方法设计模式和桥接模式之间的区别？

因为据我了解，这两种设计模式都用于分离接口(interface)和实现:

从实现中解耦抽象。抽象将客户端代码与实现分开。因此，可以在不影响客户端代码的情况下更改实现，并且在实现更改时无需编译客户端代码。

工厂方法:

没有工厂方法的问题:

在某些情况下，我们有一个包含一些类的库来实现客户端业务逻辑。我们从客户端应用程序创建库类的对象来完成任务。

但有时，根据客户要求合并额外的功能，我们可能需要在库中添加额外的类。然后我们需要在客户端应用程序中创建新类的对象。

因此，每次在库端进行新更改时，客户端都需要在其端进行一些相应的更改并重新编译代码。

使用工厂方法:

为了避免这个问题，我们使用工厂方法将对象创建与客户端应用程序分离。客户端只需要调用库的工厂方法，而不用担心创建对象的实际实现。

因此我们创建工厂方法来创建对象并将其移动到单独的实现文件中。现在，实现文件是唯一需要派生类知识的文件。因此，如果对任何派生类进行了更改，或者添加了任何新类，则实现文件是唯一需要重新编译的文件。每个使用工厂的人都只会关心接口(interface)，它应该在应用程序的整个生命周期中保持一致。

客户端应用交互-> 工厂方法和调用--> 实现

如果我采用下面的示例程序，在添加任何类或对类进行任何更改后是否仅重新编译 Vehicle.cpp 文件就足够了？还有在创建工厂方法时，我们是否使用静态方法？

Vehicle.h

#include <iostream> 
using namespace std; 

enum VehicleType { 
    VT_TwoWheeler,    VT_ThreeWheeler,    VT_FourWheeler 
}; 

// Library classes 
class Vehicle { 
public: 
    virtual void printVehicle() = 0; 
    static Vehicle* Create(VehicleType type); 
}; 
class TwoWheeler : public Vehicle { 
public: 
    void printVehicle() { 
        cout << "I am two wheeler" << endl; 
    } 
}; 
class ThreeWheeler : public Vehicle { 
public: 
    void printVehicle() { 
        cout << "I am three wheeler" << endl; 
    } 
}; 
class FourWheeler : public Vehicle { 
    public: 
    void printVehicle() { 
        cout << "I am four wheeler" << endl; 
    } 
}; 

Vehicle.cpp(执行文件)

// Factory method to create objects of different types. 
// Change is required only in this function to create a new object type 
Vehicle* Vehicle::Create(VehicleType type) { 
    if (type == VT_TwoWheeler) 
        return new TwoWheeler(); 
    else if (type == VT_ThreeWheeler) 
        return new ThreeWheeler(); 
    else if (type == VT_FourWheeler) 
        return new FourWheeler(); 
    else return NULL; 
} 

Client.h文件

// Client class 
class Client { 
public: 

    // Client doesn't explicitly create objects 
    // but passes type to factory method "Create()" 
    Client() 
    { 
        VehicleType type = VT_ThreeWheeler; 
        pVehicle = Vehicle::Create(type); 
    } 
    ~Client() { 
        if (pVehicle) { 
            delete[] pVehicle; 
            pVehicle = NULL; 
        } 
    } 
    Vehicle* getVehicle()  { 
        return pVehicle; 
    } 

private: 
    Vehicle *pVehicle; 
}; 

// Driver program 

int main() { 
    Client *pClient = new Client(); 
    Vehicle * pVehicle = pClient->getVehicle(); 
    pVehicle->printVehicle(); 
    return 0; 
}

请提供您对此的看法。

提前致谢。

Answer 1

工厂方法 是关于创建对象的灵 active ，并提供创建新对象的条件，这些对象在创建基本代码时是未知的。例如，假设您正在为要与您的项目集成的 IO 卡设计接口(interface)包装器。您从 Decklink 卡和 Bluefish 卡开始。稍后你想在不修改任何过去代码的情况下添加 Matrox 卡，工厂模式将助你一臂之力。

桥接模式更多的是关于将接口(interface)与实现脱钩(隐藏复杂的代码)。

在您的代码中注意:假设您想添加 VT_FiveWheeler - 您必须修改 Vehicle.h 以添加枚举 VehicleType(听起来很糟糕)。创建方法可以是静态的，也可以是像这样的简单辅助函数:

namespace Vehicle {
    class Vehicle {
    public:
        virtual void printVehicle() = 0;
    };
}

namespace Vehicle {
    namespace TwoWheeler {

        class TwoWheeler : public Vehicle {
        public:
            void printVehicle() {
                cout << "I am two wheeler" << endl;
            }
        };
        shared_ptr<Vehicle> create() { return make_shared<TwoWheeler>(); }
    }
}

namespace Vehicle {
    namespace ThreeWheeler {
        class ThreeWheeler : public Vehicle {
        public:
            void printVehicle() {
                cout << "I am three wheeler" << endl;
            }
        };
        shared_ptr<Vehicle> create() { return make_shared<ThreeWheeler>(); }
    }
}

namespace Vehicle {
    class factory
    {
        typedef function<shared_ptr<Vehicle>(void) > func_t;

    public:

        //register a vehicle
        void register_vehicle(const string& name, func_t func)
        {
            registered_vehicles_.insert(make_pair(name, func));
        }

        //to create a vehicle
        shared_ptr<Vehicle> create_vehicle(string name)
        {
            return registered_vehicles_[name]();
        }

        map<string, func_t> get() { return registered_vehicles_;  }

    private:
        map<string, func_t> registered_vehicles_;
    };
}

Vehicle::factory my_vehicle_factory;


int main() {

    //register the vehicle in the factory first
    my_vehicle_factory.register_vehicle("TwoWheeler", Vehicle::TwoWheeler::create);

    auto p1 = my_vehicle_factory.create_vehicle("TwoWheeler");
    auto p2 = my_vehicle_factory.create_vehicle("TwoWheeler");

    // A new vehicle has arrived, so first registered it
    my_vehicle_factory.register_vehicle("ThreeWheeler", Vehicle::ThreeWheeler::create);
    auto p3 = my_vehicle_factory.create_vehicle("ThreeWheeler");


    p1->printVehicle();
    p2->printVehicle();
    p3->printVehicle();
}