Вызов оператора= в производном классе

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
 
template <class T>
class Vector: public vector<T>
{
public:
    float average() { return (float)accumulate(begin(), end(), 0)/size(); }
    Vector<T> distances(float point);
    Vector<T>& operator=(const Vector<T> &r) { vector<T>::operator=(r); return r; }
};
 
template <class T>
Vector<T> Vector<T>::distances(float point)
{
    Vector<T> res;
    for (int i = 0; i < size(); i++)
        res.push_back(abs(at(i)-point));
    return res;
}
 
int main()
{
    int n;
    Vector<long> a;
    Vector<float> dist;
    long tek;
    float min = 10e6, max = 0, middle;
    const float E = 0.000001;
 
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        cin >> tek;
        a.push_back(tek);
        if (tek < min)
            min = tek;
        if (tek > max)
            max = tek;
    }
 
    while (abs(max-min) > E)
    {
        middle = (max + min)/2;
        dist = a.distances(middle);
    }
    return 0;
}

template<typename T, typename Allocator = std::allocator<T>>
class Vector: public std::vector<T, Allocator>
{
   using basic = std::vector<T, Allocator>;
public:
   using basic::basic; // наследуем конструктор
   using basic::operator =; // наследуем оператор =
};
 
 
int main()
{
   Vector<int> v, v2;
   v.push_back(42);
   v2 = v;
   std::cout << v2.back() << "\n";
 
}

template <class T>
class Vector: public vector<T>
{
public:
    float average() { return (float)accumulate(begin(), end(), 0)/size(); }
    Vector<T> distances(float point);
    using vector<T>::operator=;
};

#include <iostream>
 
template<typename T, typename Allocator = std::allocator<T>>
class Vector: public std::vector<T, Allocator>
{
   using basic = std::vector<T, Allocator>;
public:
   using basic::basic;
   using basic::operator =;
 
   T average() { return std::accumulate(this->begin(), this->end(), T())/this->size(); }
   Vector distances(float point);
};
 
template<typename T, typename Allocator>
Vector<T, Allocator> Vector<T, Allocator>::distances(float point)
{
    Vector<T, Allocator> res;
    for (int i = 0; i < this->size(); i++)
        res.push_back(abs(this->at(i)-point));
    return res;
}
 
 
int main()
{
   using namespace std;
 
   int n;
   Vector<long> a;
   Vector<long> dist;
   long tek;
   float min = 10e6, max = 0, middle;
   const float E = 0.000001;
 
   cin >> n;
   for (int i = 0; i < n; i++)
   {
      cin >> tek;
      a.push_back(tek);
      if (tek < min)
         min = tek;
      if (tek > max)
         max = tek;
   }
 
   while (abs(max-min) > E)
   {
      middle = (max + min)/2;
      dist =  a.distances(middle);
   }
 
}

template <typename U, typename OtherAllocator = std::allocator<U>>
   Vector & operator =(const Vector<U, OtherAllocator>& other) {
      this->assign(other.begin(), other.end());
      return *this;
   }

using basic = std::vector<T, Allocator>;

template <typename U, typename OtherAllocator>
   Vector & operator =(const Vector<U, OtherAllocator>& other) {
      this->assign(other.begin(), other.end());
      return *this;
   }