具有不同参数的对象工厂

Question

我一直在研究工厂方法并努力寻找解决问题的方法（尽管我觉得它是直截了当的。我正在尝试创建来自同一个派生类的对象，这在前进，但他们有不同的参数。

class Base
{
public:
    Base(){};
    ~Base(){};

    std::string name;
    double base_input;
    double output;

    virtual void relation_function()=0;
};

class Derived1 : public Base 
{
public:
    double private_input;
    int multiplier;

    Derived1(std::string , double , double , int);
    ~Derived1(){};

    virtual void relation_function();
};

class Derived2 : public Base 
{
public:
    double private_input;
    int multiplier;

    Derived2(std::string , double , int);
    ~Derived2(){};

    virtual void relation_function();
};

参数根据其构造函数注入派生类中。

 Derived1::Derived1(std::string input_name, double input_base_input,double input_private_input, 
int input_multiplier){
    name=input_name;
    base_input=input_base_input;
    private_input=input_private_input;
    multiplier=input_multiplier;
 };



Derived2::Derived2(std::string input_name,double input_private_input,int input_multiplier)
    {
        name=input_name;
        private_input=input_private_input;
        multiplier=input_multiplier;
    void relation_function();};
    void Derived2:: relation_function(){output=multiplier*private_input;};


void Derived1:: relation_function(){output=multiplier*base_input*private_input;};

目前我正在手动创建派生类的实例，如下所示

std::vector<std::string> v(3);
v[0]="a";v[1]="b";v[2]="c";
for (int n=0;n<=2;n++)
Base* pderived1(new Derived1(v[n],2,2,1));

std::vector<std::string> v(2);
v[0]="d";v[1]="e";
for (int n=0;n<=1;n++)
Base* pderived1(new Derived1(v[n],5,9,9));

这并不理想，我需要首先创建一个指向派生类的构造函数的指针，以在从每个派生类创建多个实例之前“修复”/“冻结”构造函数中的一些参数。

base* (*pconstructor){string, double, double, int) = Derived (string, 2,2,1)

目的是在传递给以下函数以创建对象之前，使用指向构造函数的this指针作为主要工具来指示参数。下面的函数将充当工厂来创建派生1或派生所需的实例/对象的数量，这些实例/对象可能在其构造函数（如派生2）中具有不同的参数。

base* function(std::vector<string>){ create instances.. }

我不知道如何创建指针来操作构造函数参数，也不知道如何创建用于创建实例的函数。请提供任何线索。 提前感谢大家对 C++ 新手的帮助！

Answer 1

从问题来看，目前还不清楚实际目标是什么。但是，我不知道您是否可以拥有指向构造函数/析构函数的成员函数的指针。所以你必须放弃那个选项。

最好在构造函数实例本身时做任何检查。以下也是一个坏主意，因为它会泄漏内存：

for (int n=0;n<=1;n++)
  Base* pderived1(new Derived1(v[n],5,9,9));

您不止一次覆盖pderived1。谨慎使用new/malloc。

Answer 2

解决这个问题的好方法就是提供具有不同参数的函数：

#include <string>
#include <typeinfo>
#include <vector>
class FactoryFunction;

class Factory {
public:
   template<class T, class P1, class P2>
   void reg2(T (*fptr)(P1, P2));
   template<class T, class P1, class P2, class P3>
   void reg3(T (*fptr)(P1,P2,P3));
   template<class T, class P1, class P2, class P3, class P4>
   void reg4(T (*fptr)(P1,P2,P3,P4));
private:
    std::vector<FactoryFunction*> vec;
};
Base *derived1_factory(std::string s, double d1, double d2, int i)
 {
  return new Derived1(s,d1,d2,i);
 }
int main() {
   Factory f;
   f.reg4(&derived1_factory);
}

编辑：此设计还需要一些可能难以弄清楚的东西，特别是以下类：

class FactoryFunction {
public:
   virtual int NumParams() const=0;
   virtual void set_parameter(int i, void *p)=0; 
   virtual std::string parameter_type(int i) const=0;
   virtual void *return_value() const=0;
   virtual std::string return_type() const=0;
};
template<class T, class P1>
class FactoryFunction1 : public FactoryFunction
{
 public:
    FactoryFunction1(T (*fptr)(P1)) : fptr(fptr) { }
    int NumParams() const { return 1; }
    void set_parameter(int i, void *p) { switch(i) { case 0: param1 =*(P1*)p; break; }; }
    std::string parameter_type(int i) const { switch(i) { case 0: return typeid(P1).name(); }; }
    void *return_value(int i) const { return_val = fptr(param1); return (void*)&return_val; }
    std::string return_type() const { return typeid(T).name(); }
private:
    T (*fptr)(P1);
    T return_val;
    P1 param1;
};

然后可以实现像 reg1 这样的函数来将new FactoryFunction1<T,P1>(fptr) 存储到std::vector<FactoryFunction*>。 显然 reg1/reg2/reg3 函数也可以有 std::string 作为参数。

编辑：哦，reg4 只是缺少实现（您还需要实现其他功能）。

       template<class T, class P1, class P2, class P3, class P4>
       void Factory::reg4(T (*fptr)(P1,P2,P3,P4))
           {
           vec.push_back(new FactoryFunction4(fptr));
           }

希望它现在可以编译:)