我刚开始学习C++。我试图为向量操作的子集设计一个类（接口）。此抽象基类定义为：

// File: vect.hh
#ifndef _vect_hh
#define _vect_hh

class vect
{
    public:
        virtual double norm() const = 0;
        virtual void   add(const double scaleThis, const double scaleOther,
                           const vect& other) = 0;
        virtual double dot(const vect& other) const = 0;
        virtual vect* clone() const = 0;
        virtual vect* copy(const vect& other) const = 0;
        virtual ~vect() = default;
};
#endif

问题出现在具有参数const vect& other的函数中。因为在派生类中，我真正想要的是像const vectDerived& other这样的参数。为了举例说明这个问题，我使用原始指针对前面的类做了一个简单的实现。因为我有一些其他的问题，我会在这个问题的最后评论，我已经插入了类的完整定义。但请记住，最重要的函数是dot和add：

// File: vectDouble.hh
#ifndef _vectDouble_hh
#define _vectDouble_hh

#include <cmath>
#include <cstring>

#include "vect.hh"

class vectDouble: public vect
{
public:
    explicit vectDouble(const int n): n{n}, elem{new double[n]}
    {
        std::memset(elem, '\0', sizeof(double)*n);
    }

    ~vectDouble() override {delete[] elem;}

    vectDouble(const vectDouble& other): n{other.n}, elem{new double[n]}
    {
        std::memcpy(elem, other.elem, n*sizeof(double));
    }

    vectDouble& operator = (const vectDouble& other)
    {
        if(&other != this)
        {
            delete[] elem; n = other.n;
            elem = new double[n];
            std::memcpy(elem, other.elem, sizeof(double)*n);
        }
        return *this;
    }

    vectDouble(vectDouble&& other): n{0}, elem{nullptr}
    {
        fillClass(other, *this);
    }

    vectDouble &operator = (vectDouble&& other)
    {
        if(&other != this)
        {
            delete[] elem;
            fillClass(other, *this);
            other.elem = nullptr; other.n = 0;
        }
        return *this;
    }

    double norm() const override
    {
        double norm = 0.0;
        for(int i=0; i<n; i++)
        {
            norm += elem[i]*elem[i];
        }
        return std::sqrt(norm);
    }

    double dot(const vect& other) const override
    {
        const vectDouble &v = dynamic_cast<const vectDouble&>(other);
        double dot = 0.0;
        for(int i=0; i<n; i++)
        {
            dot += elem[i]*v.elem[i];
        }
        return dot;
    }

    void add (const double scaleThis, const double scaleOther,
          const vect& other) override
    {
        const vectDouble &v = dynamic_cast<const vectDouble&>(other);
        for(int i=0;i<n;i++)
        {
            elem[i] = scaleThis*elem[i] + scaleOther*v.elem[i];
        }
    }

    double& operator[](const int i){return elem[i];}

    const double& operator[](const int i) const {return elem[i];}

    int size() const{return n;}

    vectDouble* clone() const override
    {
        return new vectDouble(*this);
    }

    vectDouble* copy(const vect& other) const override
    {
        const vectDouble &v = dynamic_cast<const vectDouble&>(other);
        auto *t = new vectDouble(*this);
        t->n = v.n;
        std::memcpy(t->elem, v.elem, t->n*sizeof(double));
        return t;
    }

private:
    void fillClass(const vectDouble& in, vectDouble& out)
    {
        out.n = in.n; out.elem = in.elem;
    }

    int n;
    double *elem;
};
#endif

在这两个函数中，我使用const vectDouble &v = dynamic_cast<const vectDouble&>(other);将基类引用转换为具有派生类类型的引用。这是dynamic_cast的有效用例。如果不是，那么实现这一结果的正确方法是什么？
我已经说过我遇到了其他问题（很抱歉偏离了主要问题）。作为使用抽象类和前面的实现的例子，我做了这个简单而有点做作的主程序：

// File main.cc
#include <iostream>
#include <memory>
#include "vectDouble.hh"

double lsfit(const vect& dobs, const vect& dcalc)
{
    std::unique_ptr<vect> tmp(dcalc.copy(dcalc));

    return (dobs.dot(dcalc))/(dcalc.dot(*tmp));
}

void testFit()
{
    vectDouble d{10};
    vectDouble x{10};

    for(int i=0; i<x.size(); i++)
    {
        d[i] = static_cast<double>(3*i);
        x[i] = static_cast<double>(i);
    }
    std::cout << "alpha=" << lsfit(d, x) << std::endl;
}

int main()
{
    testFit();
    return 0;
}

该程序说明了所描述的界面的一个设想用例。但是，如果不使用std::unique_ptr，就会出现内存泄漏（使用g++编译器中的-fsanitize=leak选项识别）。如果，* 而不是 * 使用 unique_ptr，我想手动管理内存（作为好奇心），什么是正确的方法来清理这个结果？是否可以直接从copy函数返回std::unique_ptr？当我尝试这样做时，我收到了与错误的协变返回类型相关的错误消息。
备注：
1.该接口的目的是抽象用于表示数组的存储方案，例如文件而不是内存中的表示。
1.我知道所呈现的复制函数更类似于创建/克隆加上一个复制函数。
1.如果将来我想在基类和派生类中使用模板，那么所呈现的结构是否足够？例如，template<float> class vect{...}和template <float> class vectDerived{...}？
根据hayt的建议，我修改了vect.hh和vectDouble.hh的定义，使用了上面描述的CRTP pattern。在这些修改之后，我还将函数 lsftit 的定义修改为：

template <class Derived> double lsfit2(const Derived& dobs, const Derived& dcalc)
{
    std::unique_ptr<Derived> tmp = dcalc.clone();
    Derived *t = tmp.get();
    t->copy(dcalc);
    return (dobs.dot(dcalc))/(dcalc.dot(*t));
}

在使用此模式时，这是定义此函数的正确方法吗？