template help, operators overload and type of

[Luis G]

So basically I want to do the following operations:

CMatriz<sometype> matrix1;
sometype tg1;

matrix1+tg1;
matrix1+5.0;

However:

	// Sobrecarga de operador + 
	CMatriz<TG> operator+(const CMatriz<TG> &op); // CMatriz + CMatriz

	CMatriz<TG> operator+(const TG &op); // Matriz + objeto TG
	friend CMatriz<TG> operator+(const TG &op1,const CMatriz<TG> &op2); // objeto TG + CMatriz

	CMatriz<TG> operator+(const double &op); // CMatriz + constante
	friend CMatriz<TG> operator+(const double &op1,const CMatriz<TG> &op2); // constante + CMatriz

3rd and 4th overloads conflict with 5th and 6th when TG is double. (they become the same)

What to do?


Thanks in advance.
Perhaps you've seen the other thread, it seems that today I'm Mr. Question Man

[Guysl]

Hope that helps.

#include <iostream>
#include <typeinfo>
 
template <typename TG>
class CMatriz{

public:
 
 CMatriz<TG>&  operator+(const CMatriz<TG> &op){ // CMatriz + CMatriz
   std::cout << "1. type=<" <<  typeid(TG).name() << ">" << std::endl;
   return *this;
 }
 
 template <typename TG2>
 CMatriz<TG>&  operator+(const TG2 &op){         // CMatriz + objeto TG 
   std::cout << "2. type=<" << typeid(TG).name() << ">" << std::endl;
   return *this;
 }
 
 CMatriz<TG>&  operator+(const double &op){      // CMatriz + double    
   std::cout << "3. overload double" << std::endl;
   return *this;
 }
 
 friend CMatriz<TG> operator+(const TG &op1,const CMatriz<TG> &op2){ // objeto TG + CMatriz<TG>       std::cout << "4. friend,type=" << typeid(op1).name()<< ",CMatriz<" << typeid(TG).name() <<  ">" << std::endl;
   return op2;
 }
 
 template <typename OBJ>  ){//other obj than CMatriz's + CMatriz 
 friend CMatriz<TG> operator+(const OBJ &op1,const CMatriz<TG> &op2
   std::cout << "5.  <OBJ> = <" << typeid(OBJ).name() << ",CMatriz<" << typeid(TG).name() <<  ">> " << std::endl;
   return op2;
 }
};

int main(){
 
  CMatriz<int> a;
  std::cout << " operator+ of CMatriz<int> : " << std::endl << std::endl;
  a+a;
  a+1;
  1+a;
  a+2.0;
  3.0+a;
  std::cout << std::endl << " operator+ of CMatriz<double> : " << std::endl << std::endl;
  CMatriz<double> aa;
  aa+aa;
  aa+1;
  1+aa;
  aa+2.0;
  2.0+aa;
 
  system("PAUSE"); 
  return 0;
}

[NMTop40]

I would implement operator+= and then do operator+ in terms of +=, as operator+ is hard to implement correctly as a class member. For example, it is a const method, producing a new matrix, not returning the current one. Thus return *this is wrong.

Sometimes you can create a special class to optimise a chain of plusses that simply creates a list of the items being added, and an implicit constructor from that list. For example, let's say we have a class MatrixList (internally contains a list of pointers to const matrices).

Then you can define:

MatrixList operator+( const Matrix & lhs, const Matrix & rhs );

and you'd have a constructor:

Matrix(  const MatrixList & );

The point is that it would then be quicker to add together multiple matrices thus:

S = A + B + C + D;

where they are all matrices, with much reduced allocations.

Note: this approach can be templated and forms a template pattern.