模板继承另一个模板？

Question

我正在尝试对我的数学向量从Vector继承的最大到最低进行排序，问题是我看不到inhert函数（请参阅下面的&&&&&）

template <class T>
class Vector
{
protected:
    T*      Array;
    int     Size;
    int     Capacity;

    public:


    Vector();
    Vector(Vector<T>& Copy_Array);

    T       operator=(const T* Element);
    void    operator=(const T Element);
    T*      operator[](const int Index) const;
   ostream& operator<<(const  Vector<T>& Print_Elements);


    void    Insert(T Element);/*Push*/
    void    ReSize(const int New_Size);
    T*      Pop();

    void    Set_size(int New_Size);
    void    Set_Capacity(int New_Capacity);

    int     Get_Size()     const;
    int     Get_Capacity() const;

    T*       Top()         const;

    ~Vector();
   };

---

这是仅继承curse（protected）函数的正确方法吗

 template<class T>
 class MathVector:public Vector<T>/*<- form template to tamplate*/
{ 
    public:
    void    Sort(const int Direction); 

};

&&&&&& // *我看不到vector * / &&&&&&的公共方法

template<class T>
void MathVector<T>::Sort(const int Direction)
{

this->  &&&&&&/* i can't see the public mathods of vector*/&&&&&&


};

Answer 1

是的，这是从Vector<T>继承的正确方法。 并使用公共方法编写示例

template<class T>
void MathVector<T>::Sort(const int Direction)
{
    Vector<T>::yourNonPrivateMethod();
    auto test = Vector<T>::yourNonPrivateMember;
};

您也可以通过在头文件中using声明它们：

using Vector<T>::yourNonPrivateMethod;

编辑这里是一个简化的示例：

#include <iostream>

template<typename T> class Base
{
public:
    Base() : member( static_cast<T>( 0 ) ) {};

    virtual ~Base() = default;

    T member;

    void baseMemberFunction()
    {
        std::cout << "Base<T>::memberFunction()" << std::endl;
    }

    void anotherBaseMemberFunction()
    {
        std::cout << "Base<T>::anotherBaseMemberFunction()" << std::endl;
    }
};


template<typename T> class Derived : public Base<T>
{
public:
    Derived() : Base<T>(), member(1) {}

    T member;

    using Base<T>::anotherBaseMemberFunction;

    void derivedMemberFunction()
    {
        std::cout << "Derived<T>::derivedMemberFunction()" << std::endl;
        Base<T>::baseMemberFunction();
        anotherBaseMemberFunction();
        std::cout << "Derived<T>::member = " << member << std::endl;
        std::cout << "Base<T>::member = " << Base<T>::member << std::endl;
    }
};


int main()
{
    Derived<int> derived;

    std::cout << " --- Call baseMemberFunction --- " << std::endl;
    derived.baseMemberFunction();

    std::cout << " --- Call derivedMemberFunction --- " << std::endl;
    derived.derivedMemberFunction();

    return 0;
}