ambiguos overload error bei operatorüberladung...brauche hilfe

Braineater

hallo,
wir sitzen grad an einem matrizenprojekt in dem wir mit operatorüberladung arbeiten sollen.wir haben den * operator für matrizenoperation überladen,das ging eigentlich auch immer bis wir templates für die typenunabhängigkeit eingebunden haben nun bekomme ich immer folgenden fehler

ambiguous overload for 'operator*' in 'm1 * m2'

hier mal unser quelltext
header

#include <iostream>
#include <vector>

using namespace std;

template<class T> class P_matrix;                   // Vorwärtsdeklaration der Klasse - vorherige Bekanntmachung der Klasse damit die friend Funktionen diese kennen
template<class T> ostream & operator << (ostream & os, const P_matrix<T> &m);  // Bekanntmachung das es die Operatoren als Template gibt, um diese in der Klasse als friend erklären zu können
template<class T> P_matrix<T> operator * (const P_matrix<T> &MATRIX_A, const P_matrix<T> &MATRIX_B);
template<class T> P_matrix<T> operator + (const P_matrix<T> &MATRIX_A, const P_matrix<T> &MATRIX_B);

struct newline{};

template <class T>            // dies ist eine Template-Klasse
class P_matrix {              

private:
	vector<vector<T> > mv;    // Matrixvektor
	vector<T> l_vektor;       // Lösungsvektor (hiermit wird die Matrix für Gauss zusammengebaut - Lösung in der letzten Spalte der Matrix)
	vector<T> erg_vec;        // Ergebnisvektor für die Rückauflösung (Ergebnis nach Anwendung des Gauss-Algorithmus auf die Matrix)
    int index;                // Durchläuft die Matrix bei der Eingabe
    T Determinante;     // Hier wird der Wert der Determinante gespeichert 

public:
	P_matrix(void);                                         // erstellt den ersten Zeilenvektor der Matrix und initialisiert die Variable index für die Eingabe
    //P_matrix(int n, int m);
    //~matrix(void);

	void set_determinante();                                // Errechnet die Determinante einer nxn Matrix
    T get_determinante();
    void Zeilenumformung();                                 // Bilden der Dreiecksmatrix (Nullen erstellen)
    void Rueckaufloesung();                                 // Errechnen der Ergebnisse und füllen des Ergebnisvektors
    void Vertausche(int z1, int z2);                        // Vertauschen zweier übergebenen Zeilen in der Matrix
    void Ergebnisausgabe();                                 // Ausgabe des Ergebnisvektors
    void pivot(int zeile,int spalte);                       // ermittelt das Pivotelement (rekursiv)

    P_matrix& operator >> (const T WERT);                    // Anhängen eines Wertes an die Matrix
	P_matrix& operator >> (const struct newline N);         // Erstellt einen neuen Zeilenvektor für die Matrix
	P_matrix& operator += (const P_matrix &MATRIX);         // Addiert eine Matrix auf eine andere
	P_matrix& operator *= (const P_matrix &MATRIX);         // Multipliziert eine Matrix auf eine andere
	friend ostream & operator << <>(ostream & os, const P_matrix<T> &m);     // Ausgabe einer Matrix über den ostream Operator
	friend P_matrix<T> operator * <>(const P_matrix<T> &MATRIX_A, const P_matrix<T> &MATRIX_B);      // Multiplikation zweier Matritzen in eine Ergebnismatrix
	friend P_matrix operator + <>(const P_matrix &MATRIX_A, const P_matrix &MATRIX_B);               // Addition zweier Matrizen in eine Ergebnismatrix

};

cpp(nur die überladung des * operators)

...
//// Multiplikation zweier Matrizen in eine Ergebnismatrix /////////////////////

template<class T>
P_matrix<T> & operator * (const P_matrix<T> &MATRIX_A, const P_matrix<T> &MATRIX_B)
{
         double hilf=0;                                       //Index-Variablen um durch die Matrix zu laufen
         P_matrix<T> m_tmp;
         newline nz;      

for (int k=0; k<MATRIX_A.mv.size()-1;k++)   
{
         for (int i=0; i<MATRIX_B.mv[1].size();i++)              //Zeilenvorschub
                   {   
                for (int j=0; j<MATRIX_A.mv[k].size();j++)    //Spaltenvorschub
                {

                  hilf+=MATRIX_A.mv[k][j]*MATRIX_B.mv[j][i];

                }
                m_tmp >> hilf;
                hilf=0;
          }
        m_tmp >> nz;
}

          return m_tmp;

...
}

und wie ichs in der main aufrufe

_matrix<double> m1,m2,m3;

                         cout<<"Matrizenmuliplikation:"<<endl;

                         int help=1;
                         fflush(stdin);                                          // Tastaturbuffer leeren

cout<<"Bitte geben Sie eine Matrix ein"<<endl;
cout<<"Sie können die Werte pro Zeile direkt nacheinander durch Leerzeichen oder Tab getrennt eingeben"<<endl;
cout<<"Wenn Sie fertig mit der eingabe sind drücken Sie einfach Enter ohne neue Werte einzugeben"<<endl;
                         cout<<endl;

while(help != 0)
{
    string line;               
    getline(cin, line);

    stringstream sstr;
    sstr << line;

    double wert;
    vector<int> v;

    while (sstr >> wert)
    {
         //cout<<"string:"<<wert<<endl;
        v.push_back(wert);

    }
for(int z=0;z<v.size();z++)
{
        m1>>v[z];

}
m1>>nz;
help=v.size();
} 

cout<<"Bitte geben Sie die zweite Matrix ein"<<endl;                       
help=1;
while(help != 0)
{
    string line;               
    getline(cin, line);

    stringstream sstr;
    sstr << line;

    double wert;
    vector<int> v;

    while (sstr >> wert)
    {

        v.push_back(wert);

    }
for(int z=0;z<v.size();z++)
{
        m2>>v[z];

}
m2>>nz;
help=v.size();
} 

   m3=m1*m2;

   cout<<m3;

weiß wer wovon der fehler kommt und wie man ihn wegbekommt?

mfg

In der Vorwärtsdeklaration des Operators operator* gebt ihr ein Matrix<T> Objekt zurück. Bei der Implementierung steht dann aber eine Referenz Matrix<T>&. Deshalb die Fehlermeldung wegen des mehrdeutigen Typs des Operators.

Gruß, smasher

Braineater

danke nun gehts wieder

mfg