假设我有一堆这样的继承类:

...它们都用于生成各种多项式。类X主要是一个变量tank，类A、B等都是virtual public X，各自创建ont 类型的多项式，类 Y 进行调用。除了A和B之外，还可以添加任何其他类。

现在，除了新添加的“虚拟公共(public)”类之外，一切正常，我需要重用其他类的一些成员函数，这里来自 A 类 B。我试着做一个最简单的例子:

#include <iostream>
#include <cmath>
#include <functional>

// variable tank
class X
{
protected:
    // general variables
    double *m_c;
    int m_n;
    double m_w;
    // funcX related
    double m_r;
    int m_i {0};

public:
    ~X() = default;

    /* Simple bracketed root-finding. This is called from more than
     * one "virtual public" classes.
     */
    const double funcX(const double &x, const double &y,    \
                       std::function<const double(const double&, const int&)> fp,   \
                       const int &k)
    {
        double a {x}, b {y}, fmid;
        while (m_i<100)
        {
            m_r = 0.5*(a + b);
            fmid = fp(m_r, k);
            if (fabs(b-a) <= 1e-3)
                break;
            if (fmid < 0)
                b = m_r;
            else
                a = m_r;
            ++m_i;
        }
        return m_r;
    }
};

// one of the many classes that generate polynomials
class A: virtual public X
{
public:

    void funcA(const int &n)
    {
        // set order
        m_n = n;
        // calculate X::m_c[i]
        m_c = new double[m_n+1];
        for (short i=0; i<=m_n>>1; ++i)
        {
            int sgn {i%2 ? -1 : 1};
            m_c[i<<1] = sgn/((i + 1.0)*(i + 1.0));
        }
        // The polynomial is zero somewhere, use funcX() to find where.
        m_w = funcX(5.0, 0.0,   \
                    [this](const double &x, const int &n)   \
                    { return calcA(x, n); },    \
                    m_n);
    }

    // calculates the value of the polynomial of order n, at x
    const double calcA(const double &x, const int &n) const
    {
        double out {static_cast<double>(m_c[0])};
        for (short i=1; i<=n; ++i)
            out = m_c[i] + x*out;
        return out;
    }
};

class B: virtual public X
{
private:
    A m_a;  // otherwise the lambda function does not "catch" it
public:
    void funcB(const int &n)
    {
        // same as in A
        m_n = n;
        // same as in A, calculate coefficients
        m_c = new double[m_n+1];
        for (short i=0; i<=m_n; ++i)
        {
            int sgn {i%2 ? -1 : 1};
            m_c[i] = sgn/((i + 1)<<1);
        }
        /* Here I need A::calcA(). Instead of duplicating the code,
         * I want to call it through X::funcX(). The code compiles,
         * but it crashes.
         */
        m_w = funcX(0.5, 1.0,   \
                    [this](const double &x, const int &n)   \
                    { return m_a.calcA(x, n); },    \
                    m_n);
    }
    const double getW() const { return m_w; }
};

class Y: public A, public B
{
public:
    Y(const int &n, const int &i)
    {
        // call one of the "virtual public" classes through i
        switch (i)
        {
        case 1: funcA(n);    break;
        case 2: funcB(n);    break;
        }
    }
    void printC() { for (short i=0; i<=m_n; ++i) std::cout << m_c[i] << '\n'; }
    void printW() { std::cout << m_w << '\n'; }
    void printA(const double &x, const double &n) { std::cout << A::calcA(x, n) << '\n'; }
};

int main(int argc, char *argv[])
{
    int N {6};
    Y *y;
    for (short i=1; i<=2; ++i)
    {
        y = new Y(N, i);
        y->printC();
        y->printW();
        y->printA(1.2, N);
    }

    return 0;
}

类 X:

X::funcX() 是一种简单的寻根算法，它在多个virtual public 类(A， B 等)。 m_c, m_n, m_w 是共享变量。

类 A 和 B:

它们的主要函数是 funcA()(和 funcB() 等)，它创建多项式(在正文中，有一个 循环)，基于计算出的顺序，X::m_n。计算多项式的是 A::calcA()。这也需要由 class B 调用，或者重新定义。由于代码膨胀，我宁愿避免后者。对于我相当初级的水平来说，它看起来也不是很“专业”......

类 Y

这会根据参数 i(switch/case)调用任何 virtual public 类。

代码可以编译，但会崩溃。它打印案例。这个例子指向 A::funcA() 作为罪魁祸首，但在原始程序中我可以看到系数 m_c[i] 甚至没有初始化动态内存，如试图打印出 m_c[0] 崩溃。我尝试将 new double[] 移动到 A 中的函数中，但这不起作用。

我不知道怎么做。这有意义吗，可能吗？如果是，如何？

编辑:忘记补充一点，我不能将 calcA() 从 A 移动到顶部，在 X 中，因为每个多项式的评估方式不同，因为每个多项式都有捷径和变化，因此可以对每个多项式进行不同的优化评估。我可以使 X::calcA() 成为一个通用的，但会有性能损失，我宁愿不支付。

最佳答案

您的问题似乎是由设计问题引起的。当您需要使用其他类的方法时，这可能意味着:

1. “单一职责”原则存在问题。类做的太多了。例如，数值方程求解算法是自给自足的实体，不应该是多项式的一部分。他们可以使用任何多项式。
2. 继承树有问题。例如，应该创建一个共同的祖先，并且应该在其中包含共同的方法。请注意，如果您找不到该祖先的简短易懂的名称，那么这不是解决方案。
3. 没有正确使用继承。例如，我在您的代码中看不到虚方法，这很奇怪。

让我们更接近你的例子。您正在使用虚拟多重继承，这被认为是非常繁重的模式，通常不应使用。而且，你的代码中没有虚方法，所以你实际上根本没有使用继承。您要么必须放弃继承，要么考虑对所有类都有意义的通用方法。对于函数，这似乎是一种在指定点计算函数值的能力。然后将所有不描述多项式或函数的代码移出类。移出数值求解器。这将允许为所有支持所需接口(interface)的类重用它们。完全摆脱Y级。看来，需要用开关和枚举来模拟虚拟方法。您不需要它，将 funcA 和 funcB 重命名为 func 如果它们在语义上相同并且对不同类型的多项式执行相同的操作。

关于C++ 使用来自类似虚拟公共(public)类的成员函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39816937/