Question

我有三个类模板，它们全部使用相同的成员数据和相同方法的不同实例。

我想创建一个基类模板，并让这三个继承它：

#include <vector>
#include <memory>

template <typename Sde>
class EulerFdm
{
private:
std::shared_ptr<Sde> sde;
int NT;
public:
std::vector<double> x;  // The mesh array
double  k;              // Mesh size

double dtSqrt;
public:
EulerFdm() = default;
EulerFdm(const std::shared_ptr<Sde>& stochasticEquation, int numSubdivisions)
    : sde(stochasticEquation), NT(numSubdivisions)
{

    NT = numSubdivisions;
    k = sde->Expiry() / static_cast<double>(NT);
    dtSqrt = std::sqrt(k);
    x = std::vector<double>(NT + 1);

    // Create the mesh array
    x[0] = 0.0;
    for (std::size_t n = 1; n < x.size(); ++n)
    {
        x[n] = x[n - 1] + k;
    }
}

double  advance(double  xn, double  tn, double  dt, double  normalVar, double  normalVar2) const
{
    return xn + sde->Drift(xn, tn) * dt + sde->Diffusion(xn, tn) * dtSqrt * normalVar;
}
};


template <typename Sde>
class EulerHeun
{
private:
    std::shared_ptr<Sde> sde;
    int NT;
public:
    std::vector<double> x;  // The mesh array
    double  k;              // Mesh size

    double dtSqrt;
public:
    EulerHeun() = default;
    EulerHeun(const std::shared_ptr<Sde>& stochasticEquation, int numSubdivisions)
        : sde(stochasticEquation), NT(numSubdivisions)
    {
        NT = numSubdivisions;
        k = sde->Expiry() / static_cast<double>(NT);
        dtSqrt = std::sqrt(k);
        x = std::vector<double>(NT + 1);

        // Create the mesh array
        x[0] = 0.0;
        for (std::size_t n = 1; n < x.size(); ++n)
        {
            x[n] = x[n - 1] + k;
        }
    }

double  advance(double  xn, double  tn, double  dt, double  normalVar, double  normalVar2) const
{
    auto a = sde->Drift(xn, tn);
    auto b = sde->Diffusion(xn, tn);
    auto suppValue = xn + a * dt + b * std::sqrt(dt) * normalVar;

    return xn + 0.5 * (sde->Drift(suppValue, tn) + a) * dt
        + 0.5 * (sde->Diffusion(suppValue, tn) + b) * std::sqrt(dt) * normalVar;
}
};

template <typename Sde>
class FdmFRKI
{
private:
std::shared_ptr<Sde> sde;
int NT;
public:
std::vector<double> x;  // The mesh array
double  k;              // Mesh size

double dtSqrt;
public:
FdmFRKI() = default;
FdmFRKI(const std::shared_ptr<Sde>& stochasticEquation, int numSubdivisions)
    : sde(stochasticEquation), NT(numSubdivisions)
{
    NT = numSubdivisions;
    k = sde->Expiry() / static_cast<double>(NT);
    dtSqrt = std::sqrt(k);
    x = std::vector<double>(NT + 1);

    // Create the mesh array
    x[0] = 0.0;
    for (std::size_t n = 1; n < x.size(); ++n)
    {
        x[n] = x[n - 1] + k;
    }
}

double  advance(double  xn, double  tn, double  dt, double  normalVar, double  normalVar2) const
{
    auto sqrk = std::sqrt(dt);
    auto Wincr = sqrk * normalVar;

    auto F1 = sde->Drift(xn, tn);
    auto G1 = sde->Diffusion(xn, tn);
    auto G2 = sde->Diffusion(xn + 0.5 * G1 * (Wincr - sqrk), tn);

    return xn + (F1 * dt + G2 * Wincr + (G2 - G1) * sqrk);
}
};

我试图按如下方式构建基类FdmBase：

template<typename Sde>
class FdmBase
{
protected:
       std::shared_ptr<Sde> sde;
       int NT;
public:
       std::vector<double> x;
       double k;
       double dtSqrt;
       FdmBase() = default;
       FdmBase(const std::shared_ptr<Sde>& stochasticEquation, int numSubdivision) : sde(stochasticEquation), NT(numSubdivisions)
{
    NT = numSubdivisions;
    k = sde->Expiry() / static_cast<double>(NT);
    dtSqrt = std::sqrt(k);
    x = std::vector<double>(NT + 1);

    // Create the mesh array
    x[0] = 0.0;
    for (std::size_t n = 1; n < x.size(); ++n)
    {
        x[n] = x[n - 1] + k;
    }
}
};

但是，当我删除派生类中的私有成员时，程序无法编译。

这就是我在main（）方法中调用它的方式：

auto fdm = std::shared_ptr<EulerFdm<Sde1>>(new EulerFdm<Sde1>(sde,NT));

Answer 1

模板继承中可能存在两个不同的问题，具体取决于您调整模板以考虑继承的精确程度。

第一个潜在的问题适用于所有类，包括非模板类：您只能使用基类构造函数并在mem-initializers中直接使用该类的成员。因此，您需要通过分配将sde和NT初始化移到构造函数主体中，或者让基类构造函数对其进行初始化。使用非模板基类，则一切都会好起来。

但是对于模板类，还有第二个问题related to the way in which name resolution is performed。这将导致在您的示例中找不到基本模板类的成员，并导致您描述的错误消息。可以通过使成员在派生类中显式可见来解决此问题，如以下示例所示：

template <typename T>
class B {
protected: 
    T a,b;  
public: 
    B() : a(10) 
    {
        b = a;  
    }
};
template <typename T> 
class C : public B<T> {
public: 
    using B<T>::b;   // Doesn't find these in the name resolution
    using B<T>::a;   // so just make them explicitly visible 
    C() //: a(20)
    {
        b = a +11; 
    }
};
int main() {
    C<double> x; 
    return 0;
 }

类模板的继承

1 个答案: