Why do I get the error "invalid operands of types and to binary 'operator*'"?

The error is clear and concise, you may not understand it because it is in English, I will translate it for you:

error: invalid operands of types ‘matrix<float>*’ and ‘matrix<float>*’ to binary ‘operator*’
matrix<float>* b=a*a;
                 ~^~

error: los operandos de tipos ‘matrix<float>*’ y ‘matrix<float>*’ no son válidos para el operador binario ‘operator*’
matrix<float>* b=a*a;
                 ~^~

The compiler is marking the expression b=a*aas the source of the error, what are the types of the variables involved?

The variable ahas been defined as a pointer ( *) to the template matrixinstantiated with type float:

   matrix<float>* a;
// ~~~^~~ ~~^~~ ^
//     \     \   \____ puntero
//      \     \_______ float
//       \____________ plantilla 'matrix'

The variable bhas been defined as a pointer ( *) to the template matrixinstantiated with type float:

   matrix<float>* b=a*a;
// ~~~^~~ ~~^~~ ^
//     \     \   \____ puntero
//      \     \_______ float
//       \____________ plantilla 'matrix'

Now let's see how your multiplication operator is defined:

template <class T>
matrix<T>* matrix<T>::operator*(matrix<T>* a){
//                              ~~~^~~ ^ ^
//                                  \   \ \____ puntero
//                                   \   \_____ Tipo genérico a deducir
//                                    \________ Plantilla 'matrix'    
    return NULL;

}

The multiplication operator is defined as a member function that receives a pointer parameter ( *) to the template matrixinstantiated with type T. Since it is a member function, to the left of the (multiplication) operator there must always be an instance of matrixbut you don't have an instance of matrixyou have pointers!:

   b=a*a
//   ^ ^
//    \ \___ puntero a 'matrix<float>' ---> matrix<float>*
//     \____ puntero a 'matrix<float>' ---> matrix<float>*

It will work for you if you de-reference the left operand pointer:

   b=(*a)*a
//    ^~ ^
//     \   \___ puntero a 'matrix<float>' ---> matrix<float>*
//      \______ des-referencia matrix<float>* para obtener 'matrix<float>'

But this is nonsense, the design is completely inadequate:

• Pointers are for managing memory, they should not be used to arithmetically operate objects, thus:
  • An arithmetic operator should never receive a pointer as a parameter.
  • An arithmetic operator should never return a pointer.
• Unless the arithmetic operator is also equal (for example *=) the function should be constant or should be outside the operated class.

Taking into account the previous points, your operator should be like this:

// La función no modifica el estado de la instancia ___
   template <class T> //                               \
//                                                      |
// vvvvvvvvv <--- Devuelve una instancia              vvvvv
   matrix<T> matrix<T>::operator*(const matrix<T>& a) const {
//                                ~~^~~          ^
//                                  |            |
//                 El objeto entrante es una referencia de sólo lectura.
}

Or even better, like this:

template <class T>
class matrix {

    template <class U>
    friend matrix<U> operator*(const matrix<U> &, const matrix<U> &);
};

template <class T>
matrix<T> operator*(const matrix<T> &a, const matrix<T> &b) {
    …
}

With either option, your function mainshould look like this:

int main (){

    int x=0, y=0;
    cout<<"introduzca el numero de filas de la matriz:"<<endl;
    cin>> x;
    cout<<"introduzca el numero de columnas de la matriz:"<<endl;
    cin>>y;

    // Instancia, no puntero.
    matrix<float> a{x,y};
    // Instancia, no puntero.
    matrix<float> b=a*a;

    return 0;
}

The compiler throws the error because the first element of the product cannot be a pointer. Put another way, the operator overloading is done for an object of type matrix<T>and not for a pointer tomatrix<T> .

The following examples should fix the error:

// opcion 1: en crudo
matrix<float> * b = *a*a;

// opcion 2: con paréntesis
matrix<float> * b = (*a)*a;

// opcion 3: llamada explícita a la función
matrix<float> * b = a->operator*(a);

// opción 4: desreferenciando el puntero
matrix<float> * b = (*a).operator*(a);