c++ - 类模板的继承

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;
    }
}
};

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

这是我在 main() 方法中调用它的方式:

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

Answer 1

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

第一个潜在问题适用于所有类，包括非模板类:您只能在内存初始化器中使用基类构造函数和类的直接成员。所以需要将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;
 }