Matrizen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Matrizen

    Moin!
    Ich habe folgende Aufgabe:

    In dieser Aufgabe sollen Sie eigenständig aus einer gegeben Problemstellung eine
    Klasse Matrix implementieren. Die Klasse Matrix soll eine zweidimensionale Matrix
    enthalten und folgenden Operationen ermöglichen:
    • Addition zweier Matrizen
    • Skalarmultiplikation
    • Matrizenmultiplikation
    • Berechnung der Transponierten einer Matrix

    Die Matrix enthält nur Elemente vom Typ long.
    Um diese Aufgabe zu lösen gehen Sie wie folgt vor:
    1. Rufen Sie sich die mathematischen Hintergrund in Erinnerung
    2. Überlegen Sie sich welche Attribute und Funktionen benötigt werden
    3. Zeichnen Sie ein Diagramm Ihrer Klasse
    4. Implementieren Sie Ihre Klasse
    5. Schreiben Sie ein geeignetes Hauptprogramm, welches die Funktionen
    Ihrer Klasse demonstriert.
    matrix.h

    Quellcode

    1. #ifndef MATRIX #define MATRIX class Matrix{ private: int spalte, zeile; long number; long matrix[][]; public: Matrix(const int, const int); //~Matrix(); void print(); //void add(); }; #endif


    matrix.cpp

    Quellcode

    1. #include #include "matrix.h" using namespace std; Matrix::Matrix(const int zeile, const int spalte):this->zeile(zeile),this->spalte(spalte) { for(int i=0; i<< matrix[i][k]; }


    main.cpp

    Quellcode

    1. #include #include "matrix.h" using namespace std; int main(void) { int x1, y1, x2,y2; cout << "1. Matrix: Wieviele Zeilen: "; cin >> x1; cout << "1. Matrix: Wieviele Spalten: "; cin >> y1; cout << "2. Matrix: Wieviele Zeilen: "; cin >> x2; cout << "2. Matrix: Wieviele Spalten: "; cin >> y2; Matrix ma1(x1,y2); Matrix ma2(x2,y2); ma1.print(); ma2.print(); return 0; }


    jetzt bringt er mir ständig den Fehler, dass die Feldindizes des Arrays in der Klasse fehlen.

    Kann mir jemand sagen, wie ich richtig mache?

  • falsch: google.com/search?hl=de&q=stl+vector&lr=lang_de
    vector<long double> Vektor;
    kann einiges

    und eine Matrix kann man ja im Konstruktor schon festsetzen:
    Matrix(4,5);
    und man speichert die Einträge eben innem Doppelarray, wobei
    man die Dimensionen auch speichern sollte und die Zugriffe kapseln sollte.

    Nun macht man für die Operationen einfache Memberfunktionen, wie
    Addiere( Matrix rechteSeite);
    dann kann man schonmal M.Addiere(N) machen beispielsweise.

    Für nen Operator schreibt man dann, erstma ohne Zeiger, oder Referenz-Tricks:
    Matrix operator+(Matrix rechts)
    {
    /* prüfe Dimensionen der aktuellen unn der rechten Matrix,
    sonst - naja verkleinern *was mathematisch falsch ist* oder Exception machen. */
    A = Matrix(spalten, zeilen);
    A = (this*).Addiere(rechts);
    return A;
    }

    hm das kann man natürlich für Speichereffizienz beliebig verkomplizieren die Sache,
    aber das ist ja nicht die Aufgabenstellung :)

    P.S. als Ausgabe kann man auch für cout nen Operator << definieren, der als rechte
    Seite ne Matrix frisst, dann kann man locker schreiben:

    cout << A; // das is cool, wenn's funktioniert

    Aber kompletten Code kann ich Dir nicht senden, weil ich das erstmal nur mit Vektoren
    gemacht habe (mit der STL) und auch generell zu faul bin :D

    und überhaupt mit Referenzen wird alles so kompliziert, da muss man dann konstante
    Funktionen hier und Kopierkonstruktor dort - das war mir zuviel Nachgedenke dann.
    Mit Zeigern ginge auch einiges, DA würde man aber das objektorientierte Gesamtkonzept
    verlassen müssen.

    Edit: In Übungsaufgaben ist eh Standard, sich per DEFINE ne Konstante zu wählen, dann
    interessiert die Laufzeit keinen mehr :-), dann ist alles in der Compilezeit aufgelöst worden.

  • hier mein Vektormist:

    Quellcode

    1. #define typ double
    2. #include<vector>
    3. #include<iostream>
    4. #include<iomanip>
    5. #include<math.h>
    7. using namespace std;
    9. /* Vektor */
    11. class Vektor
    12. {
    13. public:
    14. Vektor()
    15. { };
    17. Vektor(int dim)
    18. {
    19. SetDim(dim);
    20. };
    22. Vektor(typ* array, int dim)
    23. {
    24. for (int i = 0; i < dim; i++)
    25. {
    26. m_Vektor.push_back(array[i]);
    27. }
    28. SetDim(dim);
    29. };
    31. ~Vektor()
    32. {
    33. };
    35. Vektor Add(Vektor& b)
    36. {
    37. int maxDim = 0;
    38. if(GetDim() < b.GetDim())
    39. {
    40. maxDim = GetDim();
    41. }
    42. else
    43. {
    44. maxDim = b.GetDim();
    45. }
    46. Vektor A = Vektor(maxDim);
    48. for (int i = 1; i <= m_Dim; i++)
    49. {
    50. A.SetKomp(i, GetKomp(i) + b.GetKomp(i));
    51. }
    52. return (A);
    53. };
    55. typ Skal(Vektor& b)
    56. {
    57. int maxdim;
    58. typ wert = 0.0;
    59. if((*this).m_Dim < b.GetDim())
    60. {
    61. maxdim = (*this).m_Dim;
    62. }
    63. else
    64. {
    65. maxdim = b.GetDim();
    66. }
    67. for (int i = 1; i <= maxdim; i++)
    68. {
    69. wert += GetKomp(i)*b.GetKomp(i);
    70. }
    71. return wert;
    72. };
    74. typ Norm()
    75. {
    76. return( sqrt(Skal(*this)));
    77. };
    79. Vektor Mult(typ zahl)
    80. {
    81. Vektor neu = Vektor(GetDim());
    82. for (int i = 1; i <= GetDim(); i++)
    83. {
    84. neu.SetKomp(i, GetKomp(i)*zahl);
    85. }
    86. return (neu);
    87. };
    89. ostream& Ausgabe(ostream& output)
    90. {
    91. output << "[";
    92. output << setw(5) << right << showpos; // <<scientific << showpoint;
    93. for (int i = 0; i < m_Dim; i++)
    94. {
    95. output << m_Vektor[i];
    96. if (i < m_Dim-1)
    97. {
    98. output << ", ";
    99. }
    100. }
    101. output << "]";
    102. return output;
    103. };
    105. typ GetKomp(int komp)
    106. {
    107. if ((komp > 0) && (komp <= GetDim()))
    108. {
    109. return m_Vektor[komp-1];
    110. }
    111. else
    112. {
    113. return 0;
    114. }
    115. };
    117. bool SetKomp(int komp, typ wert)
    118. {
    119. if ((komp > 0) && (komp <= GetDim()))
    120. {
    121. m_Vektor[komp-1] = wert;
    122. return true;
    123. }
    124. else
    125. {
    126. return false;
    127. }
    128. };
    130. int GetDim()
    131. {
    132. return m_Dim;
    133. };
    135. void SetDim( int dim)
    136. {
    137. m_Vektor.resize(dim);
    138. m_Dim = dim;
    139. };
    141. Vektor operator+(Vektor& b)
    142. {
    143. Vektor A = Add(b);
    144. return A;
    145. }
    147. typ operator*(Vektor& b)
    148. {
    149. return this->Skal(b);
    150. }
    152. Vektor operator*(typ k)
    153. {
    154. Vektor A = Mult(k);
    155. return (A);
    156. }
    158. private:
    159. int m_Dim;
    160. vector<double> m_Vektor;
    161. };
    163. ostream& operator <<(ostream& str, Vektor vek)
    164. {
    165. return(vek.Ausgabe(str));
    166. }
    168. int main()
    169. {
    170. typ A[7] = {2.0, 3.0, 4.0, 5.0, 7.0, 8.0, 9.0};
    171. typ B[6] = {3.0, 2.0, 1.0, 4.0, 8.0, 9.0};
    173. Vektor X = Vektor(A, 7);
    174. Vektor Y = Vektor(B, 6);
    175. Vektor Z(7);
    177. cout << "X: " << X << X.GetDim() << "\n";
    178. cout << "y: " << Y << Y.GetDim() << "\n";
    180. Z = X + Y;
    181. cout << "Z = X + Y: " << X.Add(Y) << Z.GetDim() << "\n";
    183. cout << "<x,y> = " << X.Skal(Y) << ",\n";
    184. cout << "<y,x> = " << Y.Skal(X) << ",\n";
    185. cout << "<z,z> = " << Z.Skal(Z) << ".\n";
    186. cout << "||z|| = " << Z.Norm() << ", ";
    187. cout << "||z||^2 = "<< pow(Z.Norm(),2.0) << "!\n";
    188. cout << "3*z = " << Z.Mult(3.0) << "\n";
    189. cout << "X * Y: " << (X * Y) << "\n";
    190. cout << "X * 2.0" << (X * 2.0) << "\n";
    191. cout << "X + Y: " << (X + Y) << "\n";
    192. cout << "((X + Y ) * 2.0)" << ((X + Y) * 2.0) << "\n";
    194. getchar();
    195. return 0;
    196. }
    Alles anzeigen


    Ja zugegeben, es ist primitiv, aber es funktioniert *glaub ich* halbwegs, ich hatte auch ma mit Referenzen probiert, aber da wurde zum Beispiel bei einer Multiplikation in cout << (X * 2.0) immer genau der Vektor multipliziert, und bei cout << X kam dann der doppelte Vektor raus, das war doof :)

    Übrigens im Thread unten steht als verwandtes Thema was mit ner Matrix Klasse.

    Hm UND ich bin mir nicht exakt sicher, wo hier implizite Sachen drinstecken, die C++ für mich macht, ohne dass ich's merk, z.B. die Zuweisung Z = X + Y, das hatte ich auch mal im Quellcode stehn, sollte auch gehen, jedoch habe ich weder die Zuweisung, noch eine Konstruktor-Funktion Vektor( Vektor originial) implementiert - also war bei der Sache auch etwas Glück dabei ;)

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von zyklo ()