C++ Vector und Array

  • C++/CLI

Es gibt 16 Antworten in diesem Thema. Der letzte Beitrag () ist von Gonger96.

    C++ Vector und Array

    Ich möchte mehrere Matrizen (double) darstellen.
    Diese sollen static sein. Ich will also Matrix::MeineMatrix abrufen können.
    In einer Methode brauche ich eine Auflistung solcher Matrizen. Die Länge kann dabei aber immer unterschiedlich sein. (5x5, 3x3 ...)
    Problem ist, dass ich nicht genau weiß wie ich das ganze jetzt darstellen soll.
    Das hier kann ich als Methodenkopf ja nicht benutzen. ​void Process(vector<double[][]> xyz)
    Ich würde ja jetzt die Matrix als vector darstellen. Geht jedoch nicht, da das Ding statisch sein soll.
    Die Liste der Matrizen soll man dynamisch füllen können.

    Kurzform:Ich möchte eine dynamische Liste mit festen Matrizen füllen.

    Ich suche nun eine möglichste kurze und elegante Lösung. Hat da jmd. eine Idee?

    Mach dir dich ebend selbst ne Liste. Parameteranzahl kannst du per variadic Templates realisieren.

    /Edit
    Für Matrix würde ich direkt Templates nehmen. Also matrix<m1, m2, m3...>::process. Dabei könnt man auch wieder die Nontemplate Parameter unbegrenzt machen.

    LaMiy schrieb:

    (5x5, 3x3 ...)
    Oder mach Dir pro Dimensionspaar eine abgeleitete Klasse einer gemeinsamen Basisklasse, diese Basisklasse kanst Du dann als Parameter übergeben.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @Gonger96 Die Idee ist gut. Das würde ja auch in die Richtung von @RodFromGermany gehen.
    Ich habe nur ein Problem bei der Implementierung. Ich sitze nun schon einige Minuten dran und bekomm's einfach nicht hin.
    Was ist denn hier falsch?!

    Header

    C-Quellcode

    1. #pragma once
    3. template<size_t x, size_t y>
    4. class cMatrix
    5. {
    6. public:
    7. cMatrix(double[x][y] pMatrix);
    8. ~cMatrix();
    10. private:
    11. double[x][y] matrix;
    12. };


    cpp-Datei

    C-Quellcode

    1. #include "stdafx.h"
    2. #include "cMatrix.h"
    4. template<size_t x, size_t y>
    5. cMatrix<x, y>::cMatrix(double[x][y] pMatrix)
    6. {
    8. }

    LaMiy schrieb:

    Was ist denn hier falsch?
    Ein Template kannst Du machen, wenn Du eine Instanz für double und eine für int machen willst.
    Du willst unterschiedliche Anzahlen von Membern / Operanden haben, das geht nicht über Template.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @RodFromGermany Ich wollte gerade schreiben, dass ich es so habe, dass es kompiliert.
    Nur kann ich jetzt leider nicht zuweisen. (Wahrscheinlich der Grund den du meintest)

    C-Quellcode

    1. #pragma once
    3. template<size_t x, size_t y> class cMatrix
    4. {
    5. public:
    6. cMatrix(double pMatrix[x][y]);
    7. ~cMatrix();
    9. private:
    10. double matrix[x][y];
    11. };


    Wie soll ich es denn sonst machen?
    So geht's nicht.

    C-Quellcode

    1. class cMatrix
    2. {
    3. public:
    4. cMatrix(int pX, int pY);
    5. ~cMatrix();
    6. void SetValues(double pValues[x][y]);
    8. private:
    9. int x;
    10. int y;
    11. };

    LaMiy schrieb:

    Wie soll ich es denn sonst machen?
    Probier mal meinen ersten Vorschlag:
    Spoiler anzeigen

    C-Quellcode

    1. class MatrixBase
    2. {
    3. public:
    4. MatrixBase(int pX, int pY);
    5. ~MatrixBase();
    6. void SetValues(double pValues[x][y]);
    8. protected:
    9. int x;
    10. int y;
    11. };
    12. class Matrix3_3
    13. {
    14. public Matrix3_3() : MatrixBase(3, 3)
    15. {
    16. }
    17. };
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    LaMiy schrieb:

    void SetValues(double pValues[x][y]);
    Die Deklaration?
    Die muss ohne x und y gehen: void SetValues(double pValues[][]);
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Sowas ist unnötig. Ne matrix<width, height> ist am Schönsten. Ich werde heut Abend mal ne Lösung posten. Templates sind keinesfalls nur für variable Typen da, grade diese Verwendung ist am seltensten. Du kannst dich auch mal etwas in Templates, Nontype Parameter, variadic Templates und Rekursion durch Templates einlesen.

    @Gonger96
    Hab mich eigentlich schon eingelesen. Ist in C++ nur alles etwas schwieriger.
    z.B
    Spoiler anzeigen

    C-Quellcode

    1. template<unsigned int base, unsigned int n>
    2. struct Hoch
    3. {
    4. static const int wert{base * Hoch<base, n - 1>::wert };
    5. };
    7. template<> struct Hoch<2, 0>
    8. {
    9. static const int wert{ 1 };
    10. };

    Im Moment scheitert es ja lediglich an der Darstellung des mehrdimensional Double-Arrays.
    Ich werde es mir aber nochmal genauer ansehen.

    Wie wär sowas ?
    Spoiler anzeigen

    C-Quellcode

    1. template <size_t height, size_t width, typename precision = float, typename pr = void> class matrix;
    3. template <size_t height, size_t width, typename precision>
    4. class matrix<width, height, precision, typename enable_if<((is_floating_point<precision>::value || is_integral<precision>::value) && !is_same<precision, bool>::value)>::type>
    5. {
    6. static const size_t elem_width = width;
    7. static const size_t elem_height = height;
    8. using elem_precision = precision;
    9. public:
    10. matrix()
    11. {
    12. for(size_t w = 0; w < width; w++)
    13. {
    14. for(size_t h = 0; h < height; h++)
    15. {
    16. data[w][h] = 0;
    17. }
    18. }
    19. };
    20. matrix(precision _p[][height])
    21. {
    22. if((!_p) || !(*_p))
    23. throw invalid_argument("Invalid pointer");
    25. for(size_t w = 0; w < width; w++)
    26. {
    27. for(size_t h = 0; h < height; h++)
    28. {
    29. data[w][h] = _p[w][h];
    30. }
    31. }
    32. };
    34. precision** get_data() const {return static_cast<precision**>(const_cast<precision**>(data));};
    35. void write_to_stream(ostream& str)
    36. {
    37. for(size_t w = 0; w < width; w++)
    38. {
    39. for(size_t h = 0; h < height; h++)
    40. {
    41. str << data[w][h] << ' ';
    42. }
    43. str << endl;
    44. }
    45. };
    46. private:
    47. precision data[width][height];
    48. };
    50. int main(int argc, char* argv[])
    51. {
    52. float f[4][3] = {{1, 2, 3}, {3, 4, 2}, {11, 24, 563}, {7, 4, 4}};
    53. matrix<4, 3> m(f);
    54. m.write_to_stream(cout);
    55. return EXIT_SUCCESS;
    56. }

    @Gonger96 Perfekt, das klappt prima und ist wunderbar zum Lernen! Danke.
    Jetzt habe ich aber noch ein Problem wenn ich eine Liste von Matrizen erstellen will.
    ​vector<IMatrix<0 , 0>> filter Würde ja nur Matritzen mit 0x0 entsprechen. Ich möchte aber ja XxY
    Eine Idee wäre natürlich eine Schnittstelle anzugeben die jede Matrix implementiert.
    Oder geht das irgendwie einfacher?

    matrix<0, 0> geht ja sowieso nicht, die muss mind. 1 Element haben. Du hast 2 Möglichkeiten. Entweder nimmst du ne Basisschnittstelle
    Spoiler anzeigen

    C-Quellcode

    1. class matrix_base
    2. {
    3. public:
    4. size_t get_width() const = 0;
    5. size_t get_height() const = 0;
    6. };
    (kommt in C++ kein I vor, sowas sind Microsoft Richtlinien) oder du lässt es wieder über Templates lauufen. Gibt ja Template-Template-Argumente. Die Schnittstelle wäre n bisschen blöd wegen dem ganzen gecaste. Das Schönste wäre ne eigene Collection, die kann das blöde gecaste dann intern übernehmen (ohne Typeerasure geht's nicht). Oooder du lässt die ganzen Funktionen (*, +, /, invert() etc) über die Schnittstelle laufen (kannst die da auch direkt implementieren, dann wird's ne Basisklasse) und dann einfach in eine list<> oder 'nen vector<> packen.

    @Gonger96
    Funktionen brauche ich keine. Das ganze soll einfach eine Struktur sein, die eine 2x2 (3x3 4x3 ...) Matrix speichert.
    Später muss ich nur einzelne Werte über die Indices abfragen oder über die Werte schleifen.
    Eine eigene Collection sagt mir nicht so zu, da ich das Ganze später wrappen will. Könnte dann kompliziert werden.
    Wäre also dann eine Basisschnittstelle das geeignetere?

    Wrappen kannst du das sowieso nicht. Das ist zu komplex für .Net, da haste keine Chance. Du müsstest die komplette Architektur im Wrapper umschmeißen. Am einfachsten gehst du über'n Interface, du musst ja nur die Methode get_data() rein machen.

Facebook
Telefonspende