template inherit another template? - c++

Question

Im trying to do a sort for the biggest to the lowest
my Math Vector inherit from Vector
now the Problem is i can't see the inhert function (see below &&&&&)
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();
};
is this the right way to inherit just the function ofcurse(protected)
template<class T>
class MathVector:public Vector<T>/*<- form template to tamplate*/
{
public:
void Sort(const int Direction);
};
&&&&&&/* i can't see the public mathods of vector*/&&&&&&
template<class T>
void MathVector<T>::Sort(const int Direction)
{
this-> &&&&&&/* i can't see the public mathods of vector*/&&&&&&
};

Answer 1

Yes, it is the right way to inherit from your Vector<T>. And to use the public methods write for example
template<class T>
void MathVector<T>::Sort(const int Direction)
{
Vector<T>::yourNonPrivateMethod();
auto test = Vector<T>::yourNonPrivateMember;
};
You may also declare them by using in the header file:
using Vector<T>::yourNonPrivateMethod;
EDIT
Here a simplified example:
#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;
}