template<int n,int m=n>
class matrix
{
 public:
 float Dat[n][m];

 // Konstruktoren
 //---------------------------------------------------------------------------
 matrix()
	{
		if(n==m)
		for(int i=0;i<n;i++)
			for(int t=0;t<m;t++)
				{
					if(i==t)
						Dat[i][t]=1;
					else
						Dat[i][t]=0;
				}
	}
 //---------------------------------------------------------------------------
 //Debug Methoden
 #ifdef DEBUG
 //---------------------------------------------------------------------------
 void show()
	{
	for(int i=0;i<n;i++)
	{
	for(int t=0;t<m;t++)
		{
		std::cout<<Dat[i][t]<<"\t";
		}
		std::cout<<std::endl;
		}

	}
 //---------------------------------------------------------------------------
 #endif

 //Operatoren
 //---------------------------------------------------------------------------
 matrix operator +(const matrix<n,m> &op)
	{
	matrix<n,m> erg;
	for(int i=0;i<n;i++)
		for(int t=0;t<m;t++)
			{
			erg.Dat[i][t]= this->Dat[i][t] + op.Dat[i][t];
			}
	return erg;
	}
 //---------------------------------------------------------------------------
 matrix operator -(const matrix<n,m> &op)
	{
	matrix<n,m> erg;
	for(int i=0;i<n;i++)
		for(int t=0;t<m;t++)
			{
			erg.Dat[i][t]= this->Dat[i][t] - op.Dat[i][t];
			}
	return erg;
	}
 //---------------------------------------------------------------------------
 matrix operator +(const float &op)
	{
	matrix<n,m> erg;
	for(int i=0;i<n;i++)
		for(int t=0;t<m;t++)
			{
			erg.Dat[i][t]=Dat[i][t] + op;
			}
	return erg;
	}
 //---------------------------------------------------------------------------
 matrix operator -(const float &op)
	{
	matrix<n,m> erg;
	for(int i=0;i<n;i++)
		for(int t=0;t<m;t++)
			{
			erg.Dat[i][t]=Dat[i][t] - op;
			}
	return erg;
	}
 //---------------------------------------------------------------------------
 matrix operator *(const float &op)
	{
	matrix<n,m> erg;
	for(int i=0;i<n;i++)
		for(int t=0;t<m;t++)
			{
			erg.Dat[i][t]=Dat[i][t] * op;
			}
	return erg;
	}
 //---------------------------------------------------------------------------
 matrix operator /(const float &op)
	{
	matrix<n,m> erg;
	for(int i=0;i<n;i++)
		for(int t=0;t<m;t++)
			{
			erg.Dat[i][t]=Dat[i][t] / op;
			}
	return erg;
	}
 //---------------------------------------------------------------------------
 matrix operator *(const matrix<,n> &op)
	{

	}
};

Mein Problem ist der Operator am Schluss
die Funktion soll 2 matrizen miteinander multiplizieren.
bekannterweise muss dazu matrix2 so viele Spalten haben wie matrix1 zeilen
n sind die zeilen und m die spalten in meinem template
da aber n von matrix 2 irrelevant ist müsse ich es irgendwie hinbekommen als Parameter der Funktion eine Matrix mit beliebigem n anzugeben allerdings m als n von matrix1. Wie kann ich das in C++ schreiben.
Ich hoffe das war halbwegsverständlich.

template< int n, int m=n >
class matrix
{
public:
    template< int k >
    matrix< n, k > operator*( const matrix< m, k >& b )
    {
        matrix< n, k > erg;
        // erg berechnen
        return erg;
    }
private:
    float m_dat[n][m];
};

int main()
{
    matrix< 2, 3 > m23;
    matrix< 3, 7 > m37;
    matrix< 2, 7 > m27 = m23 * m37;
    return 0;
}

Gruß
Werner

thx