Перегрузка операторов и templates

//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <stdio.h>
#pragma hdrstop
 
//---------------------------------------------------------------------------
template <class T>
 class Array_2D
 {
  public:
    // constructor
    Array_2D(unsigned wd,unsigned ht) : nWd(wd), nHt(ht), pAr(0)
    {
      if(wd > 0 && ht > 0) pAr = new T[wd * ht];
    }
 
    // destructor
    ~Array_2D() { delete[] pAr ; }
 
   // indexing (parenthesis operator)
   //  two of them (for const correctness)
 
   const T& operator () (unsigned x,unsigned y) const
   {  return pAr[ y*nWd + x ];   }
 
   T& operator () (unsigned x,unsigned y)
   {  return pAr[ y*nWd + x ];   }
 
   // get dims
   unsigned GetRows()  const { return nWd; }
   unsigned GetColns() const { return nHt; }
 
  // оператор сложения
   friend Array_2D operator + (const Array_2D &A, const Array_2D &B);
 
 // private data members
 private:
   unsigned nWd;
   unsigned nHt;
   T*       pAr;
};
 
template <class F, class T, class R>
 Array_2D<F> operator + (const Array_2D<T> &A, const Array_2D<R> &B){
 
  Array_2D<F> C(B.GetRows(),B.GetRows()) ;
 
  for(unsigned i = 0 ; i < B.GetRows() ; ++i){
    for(unsigned j = 0 ; j < B.GetRows() ; ++j){
      C(i,j) = A(i,j) + B(i,j) ;
    }
  }
 
  return C ;
 }

template <class T>
 class Array_2D
 {
  public:
    // constructor
    Array_2D(unsigned wd,unsigned ht) : nWd(wd), nHt(ht), pAr(0)
    {
      if(wd > 0 && ht > 0) pAr = new T[wd * ht];
    }
 
    Array_2D(const Array_2D& A) : nWd(A.nWd), nHt(A.nHt)
    {
       pAr = new T[nWd * nHt];
       for (int i = 0; i < nWd; ++i)
           for (int j = 0; j < nHt; ++j)
               (*this)(i, j) = A(i, j);
    }
 
    Array_2D& operator=(const Array_2D& A)
    {
       if (this != &A)
       {
           delete [] pAr;
           nWd = A.nWd;
           nHt = A.nHt;
           pAr = new T[nWd * nHt];
           for (int i = 0; i < nWd; ++i)
               for (int j = 0; j < nHt; ++j)
                   (*this)(i, j) = A(i, j);
       }
       return *this;
    }
    
    // destructor
    ~Array_2D() { delete [] pAr ; }
 
   // indexing (parenthesis operator)
   //  two of them (for const correctness)
 
   const T& operator () (unsigned x,unsigned y) const
   {  return pAr[ y*nWd + x ];   }
 
   T& operator () (unsigned x,unsigned y)
   {  return pAr[ y*nWd + x ];   }
 
   // get dims
   unsigned GetRows()  const { return nWd; }
   unsigned GetColns() const { return nHt; }
 
  // оператор сложения
  //friend Array_2D operator+ <T> (const Array_2D &A, const Array_2D &B);
 
 // private data members
 private:
   unsigned nWd;
   unsigned nHt;
   T*       pAr;
};
 
template <class T>
 Array_2D<T> operator + (const Array_2D<T> &A, const Array_2D<T> &B){
 
     Array_2D<T> C(B.GetRows(), B.GetColns()) ;
 
  for(unsigned i = 0 ; i < B.GetRows() ; ++i){
      for(unsigned j = 0 ; j < B.GetColns() ; ++j){
      C(i,j) = A(i,j) + B(i,j) ;
    }
  }
 
  return C ;
 }

template <class T1, class T2>
 Array_2D<typename std::common_type<T1, T2>::type> 
      operator + (const Array_2D<T1> &A, const Array_2D<T2> &B){
 
     Array_2D<typename std::common_type<T1, T2>::type> C(B.GetRows(), B.GetColns()) ;
 
  for(unsigned i = 0 ; i < B.GetRows() ; ++i){
      for(unsigned j = 0 ; j < B.GetColns() ; ++j){
      C(i,j) = A(i,j) + B(i,j) ;
    }
  }
 
  return C ;
 }

template <class T, class U>
auto add( T x, U y ) -> decltype( x + y ) {
    return x + y;
}

typedef Array<int> IntArr;
typedef Array<double> DoubleArr;
//вроде общий тип у них - double
//а в коде кто-то написал:
IntArr summ = IntArr() + DoubleArr();
// если тип результата - DoubleArr, то либо неявный каст DoubleArr в IntArr если он возможен,
// либо ошибка компиляции. Неявный каст может быть критичен в плане производительности.