Wie gesagt, das funktioniert mit gcc.

Nun wollte ich die Klasse mit dem Testprogramm, mit dem ich die Matrizenoperationen teste,
auch mit MS Visual Studio 2005 testen. Dabei treten jedoch in den Quellcodezeilen 68
und 84 mir unerkärliche Compile-Fehler auf. Ich habe beide Zeilen unten im Quellcode markiert. Merkwürdig ist auch, dass in Zeile
68 der - und in Zeile 84 + Operator steht, also nicht der + bzw. der * Operator, auf die sich die Fehlermeldungen beziehen. Im Listing unten sind es die Zeilennummern 51 und 68. Ich habe diese Überladungen ja für alle 4 Operatoren definiert, jedoch werden nur bei 2 Operatoren Fehlermeldungen ausgegeben. Was habe ich hier falsch gemacht?

Kann mir irgend jemand helfen? Ich bin für jeden Tipp dankbar.

vg. tesu

ps: Mit dieser Klasse möchte ich meine Programmierkenntnisse verbessern, insbesondere
Überladen von Operationen. Falls ihr in der folgenden Klassendefinition prinzipielle
Fehler entdeckt, bitte um Hinweise. Ich bin mir auch gar nicht im klaren,
warum ich bei friend Definition dieses
Ungetüm: friend matrix<T> (::operator * <>)(const T c, const matrix<T>& m ) schreiben
muss, ohne (::operator * <>) funktionierts nicht.

Hier die Fehlermeldungen und der Code der Klasse (ohne Implementierung)

Fehler in Zeile 68:

Fehler 1 error C2783: "matrix<T> operator +(const T,const matrix<T> &)":
template-Argument für "T" konnte nicht hergeleitet werden.
matrix.h 68

Fehler in Zeile 84:

Fehler 2 error C2783: "matrix<T> operator *(const T,const matrix<T> &)":
template-Argument für "T" konnte nicht hergeleitet werden.
matrix.h 84

#include "mave.h"  // Basisklasse mit elementaren Vektor/Matrizen-Operationen

// Immportant forward declarations to avoid odd warnings and linking errors!
template<class T> class matrix;
template<class T> matrix<T> operator + (const T c, const matrix<T>& m );
template<class T> matrix<T> operator - (const T c, const matrix<T>& m );
template<class T> matrix<T> operator * (const T c, const matrix<T>& m );

template <typename T> class matrix : public mave<T>
{
 public:

   // constructors
   matrix<T> (unsigned row) : mave<T>(row){rangk=-1;}
   matrix<T> (unsigned row, unsigned col) : mave<T>(row, col){rangk=-1;}
   matrix<T> (int rowl, int rowh, int coll, int colh) 
	      : mave<T>(rowl, rowh, coll, colh){rangk=-1;}

   // copy constructor
   matrix<T> (const mave<T>& m) : mave<T>(m){rangk=-1;}
   matrix<T> (const matrix<T>& m) : mave<T>(m){rangk=-1;}

   // ~ operator 
   matrix<T> operator ~(){return matrix<T>(mave<T>::operator ~(/*-:)*/));}

   // assignment operators 
   matrix<T>& operator  = (const T s);
   matrix<T>& operator  = (const matrix<T>& m);

   // numeric assignment operators
   matrix<T> operator += (T s);
   matrix<T> operator -= (T s);
   matrix<T> operator *= (T s);
   matrix<T> operator /= (T s);
   matrix<T> operator += (const matrix<T>& m);
   matrix<T> operator -= (const matrix<T>& m);
   matrix<T> operator *= (const matrix<T>& m);

   // unary operators
   matrix<T> operator + ();   // does nothing, yet satisfies true completeness
   matrix<T> operator - ();   // changes signs of all components
   matrix<T> operator ! ();   // inverse of matrix

   // binary operators
   // add scalar to components
   matrix<T> operator + (const T c);
   friend matrix<T> (::operator + <>)(const T c, const matrix<T>& m );

// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Zeile 68
   // sub scalar from components                       
   matrix<T> operator - (const T c);

   // sub components from const scalar
   friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

   // mult all matrix components by scalar c
   matrix<T> operator * (const T c);
   friend matrix<T> (::operator * <>)(const T c, const matrix<T>& m );

   // div all matrix components by scalar c
   matrix<T> operator / (const T c);

   // matrix to power p, a^p   (a*a...*a, p-times)
   matrix<T> operator ^ (unsigned int p);

   // add, sub two matrices (i,j) op (i,j)-->(i,j)
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Zeile 84
   matrix<T> operator + (const matrix<T>& rm);         
   matrix<T> operator - (const matrix<T>& rm);

   // mult matrix by matrix (i,j)*(j,k)-->(i,k)
   matrix<T> operator * (const matrix<T>& rm);

   // solve set of linear equations, Mx=r --> x = r / M  or x = r % M
   matrix<T> operator / (const matrix<T>& m);
   friend matrix<T> operator % (const matrix<T>& r, const matrix<T>& m ){return r/m;}

// . . . (noch weitere Matrizenfunktionen, lineare Gleichungen)
};

Vielen Dank für eure Hilfe!
tesu

mache mal aus deinem komischen friend so und implementiere sie auch gleich in der .h:

template <typename T> class matrix : public mave<T>
{
 public:
// ...
friend matrix<T>::operator(const T c, const matrix<T>& m )
{
  //imp.
}
// ...
}

Siehe hier: http://c-plusplus.net/forum/viewtopic-var-p-is-1210246.html#1210246 Ab da mal lesen. Hoffe mal das das, dass Problem behebt ...

Edit: Bissl weiter unten erklärt es camper nochmal genau

so wie du es schreibst, hatte ich es auch zuerst unter MSVSc++ programmiert, (wie in deinem Link habe ich cout, <<, >> auch noch überladen, das klappt bei MSVSc++ und gcc/c++.)

Der folgende Code funktioniert mit MS Visual Studio 2005 aber er funktioniert nicht mit gcc/c++ (wxDev-C++ 6.10-2):

// add scalar to components
   matrix<T> operator + (const T c);
   friend matrix<T> operator + (const T c, const matrix<T>& m );
   //// friend matrix<T> (::operator + <>)(const T c, const matrix<T>& m );

   // sub scalar from components
   matrix<T> operator - (const T c);					          
   // sub components from const scalar
   friend matrix<T>  operator - (const T c, const matrix<T>& m );
   //// friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

   // mult all matrix components by scalar c
   matrix<T> operator * (const T c);
   friend matrix<T> operator * (const T c, const matrix<T>& m );
   //// friend matrix<T> (::operator * <>)(const T c, const matrix<T>& m );

Meldungen bei gcc/c++ (wxDev-C++ 6.10-2):  

 Warnungen:  
   65 D:\Programming\000-devcpp\matrix.h [Warning] friend declaration `matrix<T> 
   operator+(T, const matrix<T>&)' declares a non-template function 
   65 D:\Programming\000-devcpp\matrix.h [Warning] (if this is not what you intended, 
   make sure the function template has already been declared and add <> after the 
   function name here) -Wno-non-template-friend disables this warning 

Fehler:   
   [Linker Error] undefined reference to `operator*(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator*(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator-(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator*(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator+(double, matrix<double> const&)'

Der folgende Code funktioniert mit gcc/c++ (wxDev-C++ 6.10-2) aber er funktioniert nicht mit MS Visual Studio 2005 :

// add scalar to components
   matrix<T> operator + (const T c);
   //// friend matrix<T> operator + (const T c, const matrix<T>& m );
   friend matrix<T> (::operator + <>)(const T c, const matrix<T>& m );

   // sub scalar from components
   matrix<T> operator - (const T c);

   // sub components from const scalar
   //// friend matrix<T> operator - (const T c, const matrix<T>& m );
   friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

   // mult all matrix components by scalar c
   matrix<T> operator * (const T c);
   //// friend matrix<T> operator * (const T c, const matrix<T>& m );
   friend matrix<T> (::operator * <>)(const T c, const matrix<T>& m );

Fehlermeldungen MS Visual Studio 2005:

Fehler	1	error C2783: "matrix<T> operator +(const T,const matrix<T> &)":
template-Argument für "T" konnte nicht hergeleitet werden. matrix.h	69

Fehler	2	error C2783: "matrix<T> operator *(const T,const matrix<T> &)":
template-Argument für "T" konnte nicht hergeleitet werden. matrix.h	87

Nachdem die Fehler bei gcc aufgetreten waren, hatte ich mittels googlen herausgefunden, dass man anstelle

friend matrix<T> operator - (const T c, const matrix<T>& m );

nun bei gcc/c++ und anderen c++ Compilern neuerdings (seit 2003?)

friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

schreiben muss. Offensichtlich kann MSVSC++ nur was mit der alten Schreibweise anfangen.
Weiss jemand dazu Näheres, und besonders: wie kann ich das Problem bei MS umgehen? (Ich möchte hier möglichst keine #ifdefs schreiben)

Viele Grüsse von tesu

// add scalar to components
   matrix<T> operator + (const T c);
   friend matrix<T> operator + (const T c, const matrix<T>& m );
   //// friend matrix<T> (::operator + <>)(const T c, const matrix<T>& m );

   // sub scalar from components
   matrix<T> operator - (const T c);					          
   // sub components from const scalar
   friend matrix<T>  operator - (const T c, const matrix<T>& m );
   //// friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

   // mult all matrix components by scalar c
   matrix<T> operator * (const T c);
   friend matrix<T> operator * (const T c, const matrix<T>& m );
   //// friend matrix<T> (::operator * <>)(const T c, const matrix<T>& m );

Meldungen bei gcc/c++ (wxDev-C++ 6.10-2):  

 Warnungen:  
   65 D:\Programming\000-devcpp\matrix.h [Warning] friend declaration `matrix<T> 
   operator+(T, const matrix<T>&)' declares a non-template function 
   65 D:\Programming\000-devcpp\matrix.h [Warning] (if this is not what you intended, 
   make sure the function template has already been declared and add <> after the 
   function name here) -Wno-non-template-friend disables this warning 

Fehler:   
   [Linker Error] undefined reference to `operator*(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator*(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator-(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator*(double, matrix<double> const&)' 
   [Linker Error] undefined reference to `operator+(double, matrix<double> const&)'

Die Linkerfehler kommen daher das du die friend funktion nicht bei der Deklaration definiert hast. ( siehe Link dbzgl. nochmal )

So:

// add scalar to components
   matrix<T> operator + (const T c);
   friend matrix<T> operator + (const T c, const matrix<T>& m )
   {
     // implementation
   }
   //// friend matrix<T> (::operator + <>)(const T c, const matrix<T>& m );

   // sub scalar from components
   matrix<T> operator - (const T c);					          
   // sub components from const scalar
   friend matrix<T>  operator - (const T c, const matrix<T>& m );
   {
     // implementation
   }
   //// friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

   // mult all matrix components by scalar c
   matrix<T> operator * (const T c);
   friend matrix<T> operator * (const T c, const matrix<T>& m )
   {
     // implementation
   }
   //// friend matrix<T> (::operator * <>)(const T c, const matrix<T>& m );

Dann sollte das in beiden Compilern funktionieren.

Davon weiß ich noch gar nichts:

nun bei gcc/c++ und anderen c++ Compilern neuerdings (seit 2003?)

friend matrix<T> (::operator - <>)(const T c, const matrix<T>& m );

Werde mich mal irgendwann darüber erkunden.;)

Du könntest ja dir auch die ganze friend-Geschichte sparen und normale Funktion definieren, die über get-Funktion Zugriff auf die gebrauchten Daten haben, falls das in deinem Design schön aussieht.

P.S.: Zudem gibts da noch ein paar Schönheitsfehler, die klären wir aber nachdem du das momentane Problem gelöst hast.

template<class T>
Matrix<T> operator*(const T& zahl, const Matrix<T>& m) {
    Matrix<T> temp = m;
    return temp *= zahl;  // Aufruf von Member-operator*=(zahl)
}

Man kann dabei vollständig auf friend-Deklarationen verzichten, weil der Member-Operator operator*=() benutzt wird (den muss es natürlich geben).
MSVC habe ich nicht, müsste es dem Posting nach aber auch können.
Weiterer Vorteil: Nutzung desselben Codes in operator*(const T& zahl, const Matrix<T>& m) (global) und operator*=(const T& zahl) (member).

ich hatte übersehen, dass du

friend matrix<T>::operator + (const T c, const matrix<T>& m );

geschrieben hattest (mit zwei Doppelpunkten).

Wenn ich diese Schreibweise verwende, bekomme ich folgende Fehlermeldung bei MSVSC++:

Fehler 1 error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt. matrix.h 70

und bei gcc/c++ v:

65 D:\Programming\000-devcpp\matrix.h ISO C++ forbids declaration of operator+' with no type 65 D:\\Programming\\000-devcpp\\matrix.hstatic int matrix<T>::operator+(T, const matrix<T>&)' must be either a non-static member function or a non-member function
65 D:\Programming\000-devcpp\matrix.h [Warning] member functions are implicitly friends of their class

vg. tesu

H

friend matrix<T>::operator + (const T c, const matrix<T>& m );

Sorry, da hatte ich mich irgendwie vertippt/verdenkt :D. Sollte natürlich so aussehen:

template <typename T> class matrix : public mave<T>
{
 public:
// ...
friend matrix<T> operator+(const T c, const matrix<T>& m )
{
  //imp.
}
// ...
}

Und nochmal "Hallo" und *verbeug* vor Herr UBr

Edit: Mach das so wie UBr es gesagt hat, nicht so wie ich meinte mit get-Funktionen. So ist es natürlich Designtechnisch am schönsten ...

Ich werde euere Vorschläge nun genau studieren und in meine Klasse einbauen. Dann melde ich mich wieder. (qKasF, ich freue mich, wenn du mich auf Schönheitsfehler hinweist. (Das ist meine erste größere Klassendefinition, und ich bin ja bereits über einige Fallstricke gestolpert. Die Sache mit (::operator - <>) und der forward-Deklaration hatte ich erst nach langem Suchen auf englischen Seiten gefunden, aber eure Deklaration ist schöner)

Viele Grüsse von tesu

edit: KasF, du hattest die Lösung ja bereits ganz am Anfang gesagt, Zitat: "Die Linkerfehler kommen daher das du die friend funktion nicht bei der Deklaration definiert hast." Sorry, ich hätte da mal genauer Lesen sollen. Deshalb mein allergrößter Dank auch an dich.

Hier ist der Code:

// add scalar to components
   matrix<T> operator + (const T c);

   // add components to scalar (Alternative von UBr)
   friend inline matrix<T> operator + (const T c, const matrix<T>& m )
   { matrix<T> s(m); for (int i = 0; i < s.roco; i++) s.mat[i] += c; return s;}

   // sub scalar from components
   matrix<T> operator - (const T c);

   // sub components from const scalar (Alternative von UBr)
   friend matrix<T> operator - (const T c, const matrix<T>& m )
   { matrix<T> s(m);  for (int i = 0; i < s.roco; i++) s.mat[i] = c - s.mat[i];
     return s;}

   // mult all matrix components of m by scalar c
   matrix<T> operator * (const T c);

   // mult scalar c by all matrix components of m (Alternative von Ubr)
   friend inline matrix<T> operator * (const T c, const matrix<T>& m )
   { matrix<T> s(m); for (int i = 0; i < s.roco; i++) s.mat[i] *= c; return s;}

Der Grund, warum ich die Operationen immer paarweise brauche ist, dass sowohl s+M als auch M+s berechenbar sein muss, wenn s ein Skalar und M eine Matrix ist. Die forward-Deklarationen sind bei deiner Lösung auch nicht mehr erforderlich.

Auf die friends konnte ich jedoch (noch) nicht verzichten, da ohne sie sowohl bei gcc als auch MSc++ eine Lawine von Fehlern auftrat.

Falls du weitere Schwachstellen im Code findest, bitte teile sie mir mit.

Viele Grüsse von tesu

1.) Implentiere deine operator +,-,/ etc. mit +=,-=,/= etc. So wie es UBr vorgeschlagen hat. Somit hast du keinen doppelten Code was auch direkt Konsistenter ist.
Nun brauchst du auch wie du im Beispiel siehst keine friends mehr. Mach das in deinem Code genauso.

Beispiel:

class MyClass {

    private:
            int zahl;
    public:
            MyClass() {}

            MyClass& operator+=(int z)
            {
                zahl += z;
                return *this;
            }

            const MyClass operator+(int z)
            {
                return MyClass(*this) += z;
            }

};

const MyClass operator+(int z, const MyClass& obj)
{
    return MyClass(obj) += z;
}

2.) Mache aus deinen "const T c"'s überall ein "const T& c". Man weiß ja nie was T sein könnte ...

Das wars erstmal

Edit: Hab dein Edit nicht gesehen das ich zwischenzeitlich weg war ...

dass ich aus const T c ein const T& c machen soll, liegt das daran, dass dann anstelle einer vollständigen Kopie eine Referenz auf c übergeben wird? Das wird dann Speicherplatz auf dem Stack einsparen und auch schneller laufen.

vg. tesu

template <typename T> class matrix : public mave<T> 
{ 
 public: 
   //matrix<T> (unsigned row) : mave<T>(row){rangk=-1;} 
   matrix (unsigned row) : mave<T>(row){rangk=-1;} 

   // ...

   // ~ operator 
   //matrix<T> operator ~(){return matrix<T>(mave<T>::operator ~(/*-:)*/));} 
   matrix operator ~(){return matrix(mave<T>::operator ~(/*-:)*/));} 

   // assignment operators 
   //matrix<T>& operator  = (const T s); 
   matrix& operator  = (const T s);

Ich weiss nichtmal ob das laut Standard überhaupt erlaubt ist das "<T>" beim ctor/dtor zu schreiben so wie du das machst. Bei Parametern-Typen/Return-Typ ist es ziemlich sicher erlaubt, nur eben auch unnötig.

dass ich aus const T c ein const T& c machen soll, liegt das daran, dass dann anstelle einer vollständigen Kopie eine Referenz auf c übergeben wird? Das wird dann Speicherplatz auf dem Stack einsparen und auch schneller laufen.

Ja so ist es, du ersparst somit schon viel ...

Zudem würde ich das noch machen was hustbaer geschrieben hat und noch alle Rückgabewerte von op+,-,* und / zu const matrix<T> machen.

Damit auch nicht ja jemand sowas machen kann:

matrix<int> a,b,c;
//...
a + b = c;

Dazu gibts aber noch was schönes von camper hier: http://c-plusplus.net/forum/viewtopic-var-p-is-1275887.html#1275887

Ich habe euere Vorschläge nun in die Matrizenklasse übernommen:

1. Alle binären Operatoren (+,-,,/) durch die zuvor definierten arithmetischen
Zuweisungsoperatoren (+=,-=,=,/=) ersetzen. Das funktioniert nun bestens,
und der Code ist wie KasF und UBr sagten viel übersichtlicher und
konsistenter.

2. const T s habe ich überall (wo es zulässig war) durch const T& s ersetzt. Mir
ist nun klar, was das bedeutet.

3. Den Vorschlag von hustbaer matrix<T> durch matrix zu ersetzen, wie in:
matrix<T>& operator = (const T s); also: matrix& operator = (const T s);
habe ich auch übernommen. Ich hatte die Schreibweise matrix<T> irgend wo
gesehen und ohne Überlegung nachgeschrieben. Mir ist jetzt klar, dass es bei
der Deklaration genügt nur matrix zu schreiben, weil das bereits eindeutig
ist. Danke hustbaer!

Hier der verbesserte Code:

// numeric assignment operators
   matrix operator += (T s);
   matrix operator -= (T s);
   matrix operator *= (T s);
   matrix operator /= (T s);
   matrix operator += (const matrix<T>& m);
   matrix operator -= (const matrix<T>& m);
   matrix operator *= (const matrix<T>& m);

   // unary operators
   matrix operator + ();   // does nothing, yet satisfies true completeness
   matrix operator - ();   // changes signs of all components
   matrix operator ! ();   // inverse of matrix

   // binary operators
   // add scalar s to all components of matrix this: *this + s
   inline matrix operator + (const T& s)
    {matrix<T> a(*this); return (a += s);}

   // add scalar s to all components of matrix m:  c + a
   friend inline matrix operator + (const T& s, const matrix<T>& m )
    {matrix<T> a(m); return (a += s);}

   // sub scalar s from all components of matrix this: *this - s
   inline matrix operator - (const T& s)
    {matrix<T> a(*this); return (a -= s);}

   // sub all components of matrix m from scalar s:
   friend inline matrix operator - (const T& s, const matrix<T>& m )
    {matrix<T> a(m); return (a = -a + s);}

   // mult all matrix components by scalar c
   inline matrix operator * (const T& s)
    {matrix<T> a(*this); return (a *= s);}

   friend inline matrix operator * (const T& s, const matrix<T>& m )
    {matrix<T> a(m); return (a *= s);}

   // div all matrix components by scalar s
   matrix operator / (const T& s)
    {matrix<T> a(*this); return (a /= s);}

   // matrix to power p, a^p   (a*a ... *a, p-times)
   matrix operator ^ (int p)
     { matrix<T> m(*this); for (int i = 1; i < p; i++ ) m *= *this; return m;}

Übrigens, ich habe auch "matrix to power p" so wie ihr das vorgeschlagen hat
abgeändert in m *= *this !!! Die ganzen Matrizenmultiplikationen, die ich da programmiert hatte, sind nun einfach weg! Das ganze wird so langsam unheimlich kurz

Leider kann ich aber auf die friends (und damit auch auf die forward-Deklarationen zu Beginn der Klasse)
immer noch nicht verzichten, denn wenn ich z.B. aus:

// add scalar s to all components of matrix this: *this + s
   inline matrix operator + (const T& s)
    {matrix<T> a(*this); return (a += s);}

   // add scalar s to all components of matrix m:  c + a
   friend inline matrix operator + (const T& s, const matrix<T>& m )
    {matrix<T> a(m); return (a += s);}

das mache:

   // add scalar s to all components of matrix this: *this + s
   inline matrix operator + (const T& s)
    {matrix<T> a(*this); return (a += s);}

   // add scalar s to all components of matrix m:  c + a
   inline matrix operator + (const T& s, const matrix<T>& m )
    {matrix<T> a(m); return (a += s);}

bekommen ich immer noch diese Fehlermeldungen:

gcc:
71 D:\Programming\000-devcpp\matrix.h `matrix<T> matrix<T>::operator+(const T&, const matrix<T>&)
[with T = int]' must take either zero or one argument

MSVC++
Fehler 1 error C2804: Binärer Operator '+' hat zu viele Parameter
E:\matrix.h 71

Ich dachte, da nun der Implementierungsteil der beiden Operatoren im Deklarationssteil steht, müssten die beiden überladenen Operatoren doch eindeutig unterscheidbar sein. Was kann da falsch sein?

@KasF, du schreibst: ... und noch alle Rückgabewerte von op+,-,* und / zu const matrix<T> machen.

Ist das z.B. so zu verstehen, dass ich für matrix<T> a(*this):

// add scalar s to all components of matrix this: *this + s
   inline matrix operator + (const T& s)
    {const matrix<T> a(*this); return (a += s);}

schreiben soll? Dann kann aber a += s nicht mehr ausgeführt werden (ich habs
also falsch verstanden)

Viele Grüsse von tesu

// matrix.h
// hier ist die Klasse matrix. ...
}; // Ende der Klasse
// DANACH erst folgen die  binären Operatoren:
template<class T>
matrix<T> operator*(const T& zahl, const matrix<T> &m) {
    matrix<T> temp = m;
    return temp *= zahl; 
}
// ... usw

friend ist nicht notwendig, weil keinerlei Zugriff auf interne Daten erfolgt, nur auf den Member-Operator, und der ist public.
Innerhalb der Klasse stehen die Kurzform-Operatoren *= usw. Diese sollten aber nicht matrix zurückgeben, sondern matrix&, weil sonst eine unnötige Kopie erzeugt wird. Die letzte Anweisung in z.B. operator+=(...) ist return *this. Dann sind auch verkettete Rechnungen möglich wie a += b += c; Hoffentlich habe ich die angefragte Problemstellung richtig interpretiert.

tesuji schrieb:

// numeric assignment operators
   matrix operator += (T s);
   matrix operator -= (T s);
   matrix operator *= (T s);
   matrix operator /= (T s);
   matrix operator += (const matrix<T>& m);
   matrix operator -= (const matrix<T>& m);
   matrix operator *= (const matrix<T>& m);

Die ganzen Zuweisungsoperatoren ( nannte man die so ? ) müssen bzw sollten alle eine Refernz auf *this zurückgeben.

Sowie wie in dem Code auf Seite 1 von mir:

MyClass& operator+=(int z)
{
     zahl += z;
     return *this;
}

Weil dies erstens perfomanter ist und zudem in einem weiter Ausdruck benutzt werden kann.

tesuji schrieb:

// add scalar s to all components of matrix m: c + a
inline matrix operator + (const T& s, const matrix<T>& m )
{matrix<T> a(m); return (a += s);}
[/cpp]
bekommen ich immer noch diese Fehlermeldungen:

gcc:
71 D:\Programming\000-devcpp\matrix.h `matrix<T> matrix<T>::operator+(const T&, const matrix<T>&)
[with T = int]' must take either zero or one argument

MSVC++
Fehler 1 error C2804: Binärer Operator '+' hat zu viele Parameter
E:\matrix.h 71

Du musst den operator+(const T&, const matrix<T>&) global definieren, sowie in MyClass ( Seite 1 ).
Durch das friend sind das ja keine Memberfunktionen. Damit sowas wie m1 = 3 + m2 funktioniert muss es ja eine globale Funktion geben die ein int und ein matrix<T> erwartet.
Deswegen die op's global machen.

Ein operator+(const T&, const matrix<T>&) als Member kann nicht funktionieren, einfaches Beispiel dazu:

// op+(const T&, const matrix<T>&) ist global
m1 = 3 + m2;
// Compiler sucht für op+ was ein int und matrix als parameter hat -> gefunden

// op+(const T&, const matrix<T>&) ist in Klasse
m1 = m2 + m3;
// Compiler sieht das als m1.operator=( m2.operator+(matrix) )
// " m2.operator+(matrix)" m2 ist matrix, matrix hat ein op+(matrix)

// op+(const T&, const matrix<T>&) ist in Klasse
m1 = 3 + m2;
// Compiler sucht für op+ was ein int und matrix als parameter hat, kann einen aber nicht finden, den es einen \3.operator+(matrix\ ja auch nicht gibt.

tesuji schrieb:

@KasF, du schreibst: ... und noch alle Rückgabewerte von op+,-,* und / zu const matrix<T> machen.

Ist das z.B. so zu verstehen, dass ich für matrix<T> a(*this):

// add scalar s to all components of matrix this: *this + s
   inline matrix operator + (const T& s)
    {const matrix<T> a(*this); return (a += s);}

schreiben soll?

Ne, so:

// add scalar s to all components of matrix this: *this + s
   inline const matrix operator + (const T& s)
    { matrix<T> a(*this); return (a += s);}

Edit: to slow ...

Ich möchte an euer Forum ein ganz grosses Dankeschön sagen. Denn so schnell, ausführlich und geduldig wie ihr hier Fragen super professionell beantwortet, habe ich sonst noch nirgendwo erlebt. Ich habe unheimlich viel von euch gelernt. Danke! (In TechInfo wird bei uns die ganze c++ oop nur sehr dürftig vermittelt, ich glaube nun auch, dass unsere beiden Profs, da auch nicht so richtig den Überblick haben, denn wir haben mit C++ fast nur einfaches C gemacht).

Hier will ich euch die ersten Rechenergebnisse mit den Matrizenoperatoren zeigen. Ich habe auch cout << überladen, und kann nun Matrizen ausgeben. Und die Indexe c(500, 333) funktionieren auch. Die Matrix c ist eine 2x4 Matrix, aber ihre Indexe sind so zu gebrauchen: c(501,335) = 10. Es werden aber nur 2x4 = 8 double allokiert. Hier die Ergebnisse:

matrix<double> c(500, 501, 333, 336)

c  = -1:
-1      -1      -1      -1
-1      -1      -1      -1

Properties of matrix c:
Rectangular matrix: 2 rows * 4 columns
row subscripts from 500 to 501
col subscripts from 333 to 336

Components:
-1      -1      -1      -1
-1      -1      -1      -1

c += 6:
5       5       5       5
5       5       5       5

c -= 1:
4       4       4       4
4       4       4       4

c *= 2:
8       8       8       8
8       8       8       8

c /= 4:
2       2       2       2
2       2       2       2

c = c+1:
3       3       3       3
3       3       3       3

c = 3+c:
6       6       6       6
6       6       6       6

c = c-2:
4       4       4       4
4       4       4       4

c = 10-c:
6       6       6       6
6       6       6       6

c = c*2:
12      12      12      12
12      12      12      12

c = c/3:
4       4       4       4
4       4       4       4

c = 2*c:
8       8       8       8
8       8       8       8

Transpose c = ~c
8       8
8       8
8       8
8       8

c *= ~c:
256     256
256     256

c = 1 + 2*(c^2) - 6*(c^3) + 9*(c^4):
3.08835e+011    3.08835e+011
3.08835e+011    3.08835e+011

Matrix c to be inverted (c(1,0) = c(0,1) = 1):
3.08835e+011    1
1       3.08835e+011

Inverse c = !c:
3.23797e-012    -1.04845e-023
-1.04845e-023   3.23797e-012

Identity I = !c * c:
1       1.2326e-028
0       1

Viele Grüsse von tesu

Ich möchte an euer Forum ein ganz grosses Dankeschön sagen. Denn so schnell, ausführlich und geduldig wie ihr hier Fragen super professionell beantwortet, habe ich sonst noch nirgendwo erlebt. Ich habe unheimlich viel von euch gelernt. Danke! (In TechInfo wird bei uns die ganze c++ oop nur sehr dürftig vermittelt, ich glaube nun auch, dass unsere beiden Profs, da auch nicht so richtig den Überblick haben, denn wir haben mit C++ fast nur einfaches C gemacht).

Keine Ursache Solange hier jemand sein Probleme schön schildert und von uns nicht erwartet das wir irgendwas für ihn machen und er selbst lernwillig ist, helfen wir den Leuten hier gerne.

Zudem lerne ich selber nur dadurch, in dem ich mich mit Problemen anderer beschäftige. Dann wird mal ab und zu da und hier nochmal nachgeschaut/-geblättert und so behalte ich auch einiges besser im Kopf, wenn ich etwas schreibe