Наследование шаблона

//array.h //array.h //array.h //array.h //array.h //array.h //array.h //array.h 
 
#ifndef Array_H
#define Array_H
 
template <class Type> 
class Array
{
protected:
  int m_size;
  Type* m_data; //m_data should be a pointer, since you want to allocate data to it
 
public:
  Array();
  Array(int new_size);
  virtual ~Array(); //Are there reason making destructor virtual?
  Array<Type>& operator=(const Array& ar); //Const correctness here.
  Type& operator [] (int index);
  const Type& operator [] (int index) const;
  int Size() const;
};
 
#ifndef Array_cpp 
#include "array.cpp"
#endif
 
#endif //Array_CPP
 
//*******************
//*******************
//*******************
//*******************
 
 
//NumericArray.h //NumericArray.h //NumericArray.h //NumericArray.h 
 
 
#ifndef NumericArray_H
#define NumericArray_H
 
#include "array.h"
 
template <class Type> 
class NumericArray: public Array<Type>
{
    public: 
        NumericArray();
        NumericArray(int new_size);
       ~NumericArray(); 
        NumericArray<Type>& operator=(const NumericArray<Type>& ar); 
        NumericArray<Type>& operator *(double factor) const;    
};
 
template <class Type>
NumericArray<Type>::NumericArray() : m_size(10), m_data(0) // default filling of array is zeros!
{
}
 
template <class Type>
NumericArray<Type>::NumericArray(int new_size) : m_size(new_size), m_data(new Type[new_size])
{ 
}
 
template <class Type>
NumericArray<Type>::~NumericArray()
{
  //Technically, the if is not necessary
  if(m_data)
  {
    delete[] m_data;
    m_data = 0;
  }
  //Not necessary either, but just to be clean
  m_size = 0;
}
 
template<class Type>
NumericArray<Type>& NumericArray<Type>::operator *(double factor) const
{
   NumericArray<Type> output(Array<Type>::Size());
   for(int i=0; i<Array::Size(); i++)
   {
      output[i] = (*this)[i] * factor;
      //return output;
   }
   return output;
}
 
template <class Type>
NumericArray<Type>& NumericArray<Type>::operator=(const NumericArray& ar) 
 
#endif //NumericArray_h 
 
//*******************
//*******************
//*******************
//*******************
 
 
 
//point.h //point.h //point.h //point.h //point.h //point.h //point.h //point.h //point.h //point.h 
#include <sstream>
#include <iostream>
 
#ifndef Point_H
#define Point_H
#include "array.h"
 
using namespace std;
class Point
{
private:
    double m_x;                                
    double m_y;                                
public:
    // Constructors
    Point(): m_x(0), m_y(0) {};                            
    Point(double new_x, double new_y) : m_x(new_x), m_y(new_y) {};
    friend ostream& operator << (ostream& os, const Point& point)
{
    return os << point.ToString();
}
    //std::string Point::ToString(void) const                // create a string representation of a point
   string ToString() const
{
// create a string like: “Point(1.5, 3.9)”
      std::ostringstream os;
    os << m_x << " , " << m_y;
    std::string double_string = os.str();
 
    return "Point(" + double_string + ")";
 
}
    //Point Point::operator * (double factor) const;
    Point operator *(double factor) const;   
    //Point& Point::operator *= (double factor); 
    Point & operator *=(double factor);
};
 
#endif //Point_h
 
 
//*******************
//*******************
//*******************
//*******************
 
//array.cpp //array.cpp //array.cpp //array.cpp //array.cpp //array.cpp //array.cpp //array.cpp 
 
 
#include "Array.h"
#include <sstream>
#include <iostream>
//#include <exception>
using namespace std;
#ifndef Array_CPP
#define Array_CPP
 
 
template <class Type>
Array<Type>::Array() : m_size(10), m_data(0) // 
{
}
template <class Type>
Array<Type>::Array(int new_size) : m_size(new_size), m_data(new Type[new_size])
{ 
}
 
template <class Type>
Array<Type>::~Array()
{
  //Technically, the if is not necessary
  if(m_data)
  {
    delete[] m_data;
    m_data = 0;
  }
 
  //Not necessary either, but just to be clean
  m_size = 0;
}
template <class Type>
Array<Type>& Array<Type>::operator=(const Array& ar)
{
  //Check self assign:
  if(this == &ar) {return *this;}
  Array<Type> copy(ar); //Create a copy of ar; If this fails, then *this will not be changed, and nothing will leak
  //Succeeded creating copy. Now we can put it inside this
  this->Swap(copy); //And then swap the copy into this!
  return *this;
}
 
 
 
 
 
template <class Type> 
Type& Array<Type>::operator [] (int index) 
{
    if (index > this->m_size)
    {
        cout << "i am hreeeee" << endl;
        return this->m_data[0];
    }
    return m_data[index];
}
 
template <class Type> 
 const Type& Array<Type>::operator [] (int index) const
 {
  //  cout << "Array [] operator" << endl;
 
    if (index > this->m_size)
    {
        cout << "i am hreeeee" << endl;
        return this->m_data[0];
    }
    return m_data[index];
}
 
template<class Type>
int Array<Type>::Size() const
{
    return this->m_size; 
}
 
 
 
/*template<class Type>
//Type& Array<Type>::operator * (double factor) const
Array<Type> Array<Type>::operator *(double factor) const
{
   Array<Type> output(Array<Type>::Size());
   for(int i=0; i<Array::Size(); i++)
   {
      output[i] = (*this)[i] * factor;
      //return output;
   }
   return output;
}*/
 
 
 
 
 
 
 #endif //Array_CPP
 
//*******************
//*******************
//*******************
//*******************
 
// Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp // Point.cpp 
 
 
#include "Point.h"
#include <sstream>
#include <iostream>
using namespace std;
 
  Point Point::operator * (double factor) const
{
    return Point(m_x * factor, m_y * factor);
}
 
    Point& Point::operator *= (double factor)
        {
    Point tmp = (*this) * factor;
    *this = tmp;
    return *this;
        }
 
 
//****************
//****************
//****************
 
 
//main.cpp //main.cpp //main.cpp //main.cpp //main.cpp //main.cpp //main.cpp //main.cpp 
 
        #include "point.h"
        #include "Array.h"
        #include "array.cpp"
    //  #include <exception>
        #include "NumericArray.h"
        #include <iostream>
        using namespace std;
int main()
{
              //Create two Point arrays and test the operators
    NumericArray<Point> pArray1(5);
    NumericArray<Point> pArray2(5);
    //initialize
    for(int i=0; i<pArray1.Size(); i++) pArray1[i] = Point(i, i);
    for(int i=0; i<pArray2.Size(); i++) pArray2[i] = Point(2*i, 2*i);
 
    //Numeric Array's operations not working for Point objects
 
 
    cout << "times PointArray1 by 3 and print out the new array: "<< endl;
    NumericArray<Point> answ1 = pArray1 * 3;
    
    for(int i=0; i<answ1.Size(); i++)
    {
        cout << answ1[i] << endl;
    }
}

template <class Type>
NumericArray<Type>& NumericArray<Type>::operator=(const NumericArray& ar)

 template <class Type>
NumericArray<Type>& NumericArray<Type>::operator=(const NumericArray& ar) 
{
  //Check self assign:
  if(this == &ar) {return *this;}
  Array<Type> copy(ar); //Create a copy of ar; If this fails, then *this will not be changed, and nothing will leak
  //Succeeded creating copy. Now we can put it inside this
  this->Swap(copy); //And then swap the copy into this!
 return *this;
}

template <class Type>
NumericArray<Type>::NumericArray(int new_size) : m_size(new_size), m_data(new Type[new_size])
{ 
}

template<class Type>
NumericArray<Type>::NumericArray(int new_size) : Array<Type>(size)
{
}

template <typename T, typename Obj>
Array<T> operator + (const Array<T>& arr, const Obj& obj)
{
    Array<T> result(arr);
    // тут для каждого элемента из массива идет сложение:
    result[i] += obj; // подправил тут. конечно же нужно к result[i] прибавлять
    return result;
}