Matrix in Funktionen übergeben

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

  • Matrix in Funktionen übergeben

    Hi,
    bin neu in C und würde gerne einen Gauss-Algorithmus implementieren. Leider scheitert es bereits an dem Problem, eine Matrix als 2-dimensionales Array zu ergzeugen, mit Daten zu füllen und auszugeben. Mein Code sieht so aus (poste nur die Routinen, die dafür relevant sind):


    Quellcode

    1. #include <stdio.h>
    2. #include <stdlib.h>
    5. double **matrix;
    6. int m,n;
    8. double** InitMatrix(int rows, int cols){
    9. double **t;
    10. int i;
    11. t=malloc(rows * sizeof(double*) + rows * cols * sizeof(double));
    12. for(i=1; i<=rows; i++)
    13. t[i]= (double*) &t[rows +cols*i];
    14. //*t[i]= (double*) t + rows +cols*i;
    16. return t;
    17. }
    19. void PrintMatrix(double **pmatrix)
    20. {
    21. int i,j;
    22. printf("\n");
    23. for(i=1; i<=m; i++)
    24. {
    25. printf("[");
    26. for(j=1;j<=n;j++)
    27. printf(" %.3f ",pmatrix[i][j]);
    28. printf("]\n");
    29. }
    30. printf("\n");
    31. }
    33. int main()
    34. {
    35. m=4;
    36. n=4;
    37. matrix=InitMatrix(m+1,n+1);
    39. matrix[1][1]=1;
    40. matrix[1][2]=2;
    41. matrix[1][3]=3;
    42. matrix[1][4]=4;
    44. matrix[2][1]=5;
    45. matrix[2][2]=7;
    46. matrix[2][3]=9;
    47. matrix[2][4]=1;
    49. matrix[3][1]=3;
    50. matrix[3][2]=8;
    51. matrix[3][3]=1;
    52. matrix[3][4]=2;
    54. matrix[4][1]=4;
    55. matrix[4][2]=6;
    56. matrix[4][3]=8;
    57. matrix[4][4]=2;
    59. PrintMatrix(matrix);
    61. free(matrix);
    63. return 0;
    64. }
    Alles anzeigen


    Das Programm wird fehlerfrei compiliert, allerdings erscheint die folgende Matrix auf dem Bildschirm:

    [ 5 2 0 0 ]
    [ 5 7 0 0 ]
    [ 3 8 0 0 ]
    [ 4 6 8 2 ]

    Offenbar werden also einige Werte korrekt übernommen, andere nicht. Ich bin mir ziemlich sicher, dass es an der Initialisierung der Matrix liegt. Da ist irgendwas falsch. Die auskommentierte Zeile hatte ich zuerst verwendet und die sollte ja eigentlich auch richtig sein oder? Mit der geht es allerdings überhaupt nicht. Dann kommt zur Laufzeit ein Fehler ("DAMAGE: after normal Block #42 at...").

    Benutze VC++6 Pro unter Win XP. Habe das Programm einem Kumpel gegeben, bei dem der Fehler angeblich nicht auftritt. Habe es dann noch einem anderen Kumpel gegeben, der hat denselben Fehler. Irgendeine Feinheit nicht beachtet, die compilerabhängig unterschiedlich behandelt wird???

  • Probiers mal so (Indizes sind immer 0-based!):

    Quellcode

    1. #include <stdlib.h>
    2. #include <stdio.h>
    4. void SetValue(double** pmatrix, unsigned int row, unsigned int col, double d)
    5. {
    6. pmatrix[row][col] = d;
    7. }
    9. double GetValue(double** pmatrix, unsigned int row, unsigned int col)
    10. {
    11. return pmatrix[row][col];
    12. }
    14. double** InitMatrix(unsigned int rows, unsigned int cols)
    15. {
    16. // allocate all rows
    17. double** t = (double**) malloc(rows * sizeof(double*));
    18. // allocate all columns for each row
    19. for (unsigned int r = 0; r < rows; ++r)
    20. {
    21. t[r] = (double*) malloc (cols * sizeof (double));
    23. // set the initial value
    24. for (unsigned int c = 0; c < cols; ++c)
    25. SetValue (t, r, c, 0.0);
    26. }
    27. return t;
    28. }
    30. void PrintMatrix(double** pmatrix, unsigned int rows, unsigned int cols)
    31. {
    32. unsigned int r,c;
    33. printf("\n");
    34. for(r=0; r<rows; r++)
    35. {
    36. printf("[");
    37. for(c=0;c<cols;c++)
    38. printf(" %.3f ",GetValue (pmatrix, r, c));
    39. printf("]\n");
    40. }
    41. printf("\n");
    42. }
    44. void FreeMatrix (double** pmatrix, unsigned int rows)
    45. {
    46. unsigned int r;
    47. for (r = 0; r < rows; ++r)
    48. free (pmatrix[r]);
    49. free (pmatrix);
    50. }
    52. int main()
    53. {
    54. unsigned int r=4;
    55. unsigned int c=4;
    56. double** matrix=InitMatrix(r,c);
    58. SetValue (matrix, 0, 0, 1);
    59. SetValue (matrix, 0, 1, 2);
    60. SetValue (matrix, 0, 2, 3);
    61. SetValue (matrix, 0, 3, 4);
    63. SetValue (matrix, 1, 0, 5);
    64. SetValue (matrix, 1, 1, 7);
    65. SetValue (matrix, 1, 2, 9);
    66. SetValue (matrix, 1, 3, 1);
    68. SetValue (matrix, 2, 0, 3);
    69. SetValue (matrix, 2, 1, 8);
    70. SetValue (matrix, 2, 2, 1);
    71. SetValue (matrix, 2, 3, 2);
    73. SetValue (matrix, 3, 0, 4);
    74. SetValue (matrix, 3, 1, 6);
    75. SetValue (matrix, 3, 2, 8);
    76. SetValue (matrix, 3, 3, 2);
    78. PrintMatrix(matrix, r, c);
    80. FreeMatrix(matrix, r);
    82. return 0;
    83. }
    Alles anzeigen


    Das ganze solltest du aber lieber in C++ machen :)

  • In C++ könnte das ganze so aussehen:

    Quellcode

    1. #include <stdlib.h>
    2. #include <stdio.h>
    3. #include <assert.h>
    5. template <class T>
    6. class Matrix
    7. {
    8. private:
    9. const size_t m_rows, m_cols;
    10. T** m_values;
    12. public:
    13. Matrix (size_t rows, size_t cols)
    14. : m_rows (rows),
    15. m_cols (cols)
    16. {
    17. // allocate all rows
    18. m_values = (T**) malloc (m_rows * sizeof(T*));
    20. // allocate all columns for each row
    21. for (size_t r = 0; r < m_rows; ++r)
    22. m_values[r] = (T*) malloc (m_cols * sizeof (T));
    23. }
    25. virtual ~Matrix ()
    26. {
    27. for (size_t r = 0; r < m_rows; ++r)
    28. free (m_values[r]);
    29. free (m_values);
    30. }
    32. void setValue (size_t row, size_t col, const T& aValue)
    33. {
    34. assert (row < m_rows && col < m_cols);
    35. m_values[row][col] = aValue;
    36. }
    38. const T& getValue (size_t row, size_t col)
    39. {
    40. assert (row < m_rows && col < m_cols);
    41. return m_values[row][col];
    42. }
    44. void print ()
    45. {
    46. size_t r,c;
    47. printf("\n");
    48. for(r=0; r < m_rows; r++)
    49. {
    50. printf("[");
    51. for(c=0;c < m_cols;c++)
    52. printf(" %.3f ", getValue (r, c));
    53. printf("]\n");
    54. }
    55. printf("\n");
    56. }
    57. };
    59. int main()
    60. {
    61. Matrix<double> *m = new Matrix<double> (4, 4);
    62. m->setValue (0, 0, 1);
    63. m->setValue (0, 1, 2);
    64. m->setValue (0, 2, 3);
    65. m->setValue (0, 3, 4);
    67. m->setValue (1, 0, 5);
    68. m->setValue (1, 1, 7);
    69. m->setValue (1, 2, 9);
    70. m->setValue (1, 3, 1);
    72. m->setValue (2, 0, 3);
    73. m->setValue (2, 1, 8);
    74. m->setValue (2, 2, 1);
    75. m->setValue (2, 3, 2);
    77. m->setValue (3, 0, 4);
    78. m->setValue (3, 1, 6);
    79. m->setValue (3, 2, 8);
    80. m->setValue (3, 3, 2);
    82. m->print ();
    84. delete m;
    85. return 0;
    86. }
    Alles anzeigen