C++中用户定义类的动态分配，具有相同的公共功能

Question

首先，我是一个物理学家，所以我的编码经验和知识是有限的，所以道歉，如果我没有使用正确的术语，或者如果这个问题的答案已经存在。我一直找不到任何对我来说有意义的足够相似的东西。你知道吗

现在，我正在对一些量子系统进行蒙特卡罗模拟，在这里面我需要一些特定的多项式。我已经为所有这样的多项式编写了课程。它们在初始化时都采用相同的参数（一个字符串和一个整数），从外部角度看，它们中唯一的公共方法都是相同的（它接受一个复数double数组并输出一个复数double）。总的情况是

class Polyi{
    public:
        Polyi(string type, int N){
            ::Set things up if needed::
        }

        complex<double> poly(complex<double> *z){
            ::Calculate the polynomial and return::
        }
}

现在，我希望在给定的模拟中使用的多项式必须是我可以从外部输入的。我更习惯Python

if poly_type==i: polynomial = Polyi(type, N)
elif ...

是我想做的。然后在后续代码中使用polynomial.poly(z)。你知道吗

<>但是，这在C++中被证明是非常困难的，因为我必须声明我在赋值中使用的类的类型。我试过几种方法。我做了一个包含所有多项式的处理程序。没用。我还尝试为所有这些函数创建一个基类，包括poly(z)函数，然后在每个函数中重载它。我在这里也不够。然而，它们不起作用可能是因为我是个白痴，而不是因为它们实际上不可能实现。你知道吗

因此，我如何实现这种动态赋值，当我进行实际计算时，在变量polynomial中有一个所需的多项式，无论是什么类的，我都可以调用polynomial.poly(z)？如果可能的话，解决这个问题的最简单的解决方案会非常棒，因为我希望能够理解代码实际上在做什么。你知道吗

谢谢你能给我的任何帮助！你知道吗

编辑：非常感谢大家！没有一条毫无帮助的评论/答案，也没有很多值得一看的好建议。谢谢大家！！！你知道吗

注：为了澄清，虽然它似乎不是一个关键点，type变量定义了一类多项式中的一类多项式。例如，对于Pn多项式，Pn（“1”，N）=z1+z2+…+zN，Pn（“2”，N）=z1^2+z2^2+…zN^2等等。在更复杂的方面，我有杰克多项式，它是由整数的分区索引的（如11122或223）。我不知道如何生成它们，所以我下载了一个带有它们的文件，这就是为什么它是一个字符串。你知道吗

Answer 1

我想说这是一个完美的工厂设计模式的地方。你知道吗

class iPoly{
public:
    virtual ~iPoly(){}
    virtual complex<double> poly(complex<double> *z) = 0;
};

class Polyi : public iPoly {
public:
    Polyi(string type, int N);
    virtual ~Polyi(){}
    virtual complex<double> poly(complex<double> *z);
};

class Polyb : public iPoly {
public:
    Polyb(string type, int N);
    virtual ~Polyb(){}
    virtual complex<double> poly(complex<double> *z);
};


iPoly* make_poly(string type, int N) {
  if (type=="Polyi") {
     return new Polyi(type,N);
  } else if (type=="Polyb") {
     return new Polyb(type,N);
  }
  return NULL;
}

Answer 2

<> C++中的多态性依赖指针。你知道吗

如果你有一个基类Poly，然后是子类Polya，Polyb，Polyi。。等。 你可以有一个Poly*实际指向一个Polya*，但是你不能有一个Poly包含一个Polya，因为你将面对类型切片。你知道吗

所以你可以有这样的东西：

class Poly_base
{
    public:
        Poly_base(string type, int N) {
            // Potentially do stuff that you do on ALL poly
        }

        virtual complex<double> poly(complex<double> *z) = 0;
}

class Polyi : public Poly_base
{
    public:
        Polyi(string type, int N):
            Poly_base(type, N)
        {
            // Stuff you would do only on Polyi.
        }

        virtual complex<double> poly(complex<double> *z)
        {
            // Your calculation for Polyi.
        }
}

注意virtual关键字。这说明：在我的基类上有一个方法，可以在子类上重新实现。 如果在实际指向Polya实例的Poly_base*指针上调用poly，则将调用重新实现的版本。（通过vtables的魔力）

然后主要是：

Poly *polynomial;
if (some_condition) {
    polynomial = new Polya(type, N);
} else if (some_other_condition) {
    polynomial = new Polyi(type, N);
}
polynomial->poly(z);

编辑：您可能希望您的类型是枚举而不是字符串，因此可以对其执行switch语句，如下所示：

enum PolyType {
    polya = 0,
    polyb,
    polyi
}

Poly_base *polynomial;
switch (type) {
    case polya:
        polynomial = new Polya(type, N);
        break;
    case polyb:
        polynomial = new Polyb(type, N);
        break;
    case ....
}

EDIT2：您可能也不需要类构造函数中的类型。。这个体系结构的要点是，这些信息包含在您实际创建的实例中。如果你创建了一个Polya，那么它“知道”它是Polya而不是Polyb。你知道吗