In allen matrix Datein das Wort space durch buffer ersetzt.

(Hab das erst im ganzen projekt gemacht, eigentlich wider rückgängig.
Falls probleme auftreten sollten das checken)

Startcode/matrix.c

@@ -12,15 +12,15 @@ Matrix createMatrix(unsigned int rows, unsigned int cols){
        unsigned int memory_reservation = 0;
        memory_reservation = memory_depth * sizeof(MatrixType);     //Nimmt die Speichertiefe mal die größe der einzelnen Speicherinhalte (float)
 
-       Matrix.space = malloc(memory_reservation);                  //Reserviert den Speicher und gibt den Zeiger auf die erste Speicheradresse dem zeiger space (malloc "merkt" sich die Speichergröße an der adresse space)
+       Matrix.buffer = malloc(memory_reservation);                  //Reserviert den Speicher und gibt den Zeiger auf die erste Speicheradresse dem zeiger buffer (malloc "merkt" sich die Speichergröße an der adresse buffer)
     */
        Matrix matrix;                                              //Matrix ist der Datentyp (im struct bestimmt). wir brauchen hier aber eine lokale variable (!NIX GLOBAL!) daher ist matrix eine Variable vom Typ Matrix.
 
        matrix.rows = rows;
        matrix.cols = cols;
-       matrix.space = malloc(rows * cols * sizeof(MatrixType));
+       matrix.buffer = malloc(rows * cols * sizeof(MatrixType));
 
-       if (matrix.space == NULL) {
+       if (matrix.buffer == NULL) {
            fprintf(stderr, "Error, matrix could not be created...\n");
            matrix.rows = 0;
            matrix.cols = 0;
@@ -37,10 +37,10 @@ void clearMatrix(Matrix *matrix){       //*matrix greift auf die einträge im St
         return;
     }
 
-    free(matrix->space);                //Mit free wird die dynamische Speichergröße (die sich malloc gemerkt hat und mit der adresse von space verknüpft hat) wieder freigegeben
+    free(matrix->buffer);                //Mit free wird die dynamische Speichergröße (die sich malloc gemerkt hat und mit der adresse von buffer verknüpft hat) wieder freigegeben
 
-    matrix->space = NULL;               //matrix->space = NULL ist das gleiche wie (*matrix).space = NULL / Setzt den Zeiger auf 0
+    matrix->buffer = NULL;               //matrix->buffer = NULL ist das gleiche wie (*matrix).buffer = NULL / Setzt den Zeiger auf 0
-    matrix->rows = 0;                   //Wir greifen auf einen zeiger in struct zu deswegen (*matrix)[zeiger auf] .space[variable im struct] !Klammer weil . stärker bindet als *!
+    matrix->rows = 0;                   //Wir greifen auf einen zeiger in struct zu deswegen (*matrix)[zeiger auf] .buffer[variable im struct] !Klammer weil . stärker bindet als *!
     matrix->cols = 0;
 }
 
@@ -53,11 +53,11 @@ void setMatrixAt(MatrixType value, Matrix matrix, unsigned int rowIdx, unsigned
         return;
     }
 
-    unsigned int memoryspace = 0;
+    unsigned int memorybuffer = 0;
     unsigned int columnlength = matrix.cols;
 
-    memoryspace = (rowIdx * columnlength)+colIdx;           //Erklärung in "getMatrixAt"
+    memorybuffer = (rowIdx * columnlength)+colIdx;           //Erklärung in "getMatrixAt"
-    matrix.space[memoryspace] = value;
+    matrix.buffer[memorybuffer] = value;
 }
 
 
@@ -68,13 +68,13 @@ MatrixType getMatrixAt(const Matrix matrix, unsigned int rowIdx, unsigned int co
         return UNDEFINED_MATRIX_VALUE;
     }
 
-    unsigned int memoryspace = 0;                           //variable für den Eintrag an der gesuchten stelle
+    unsigned int memorybuffer = 0;                           //variable für den Eintrag an der gesuchten stelle
     unsigned int columnlength = matrix.cols;                //maximale länge einer Zeile
 
-    memoryspace = (rowIdx * columnlength)+colIdx;           //Bsp. Matrix = 5 Spalten und 4 Zeilen. Gesucht ist Zeile 3, Spalte 2. In meinem Eindimensionalen Array ist das 12
+    memorybuffer = (rowIdx * columnlength)+colIdx;           //Bsp. Matrix = 5 Spalten und 4 Zeilen. Gesucht ist Zeile 3, Spalte 2. In meinem Eindimensionalen Array ist das 12
                                                             //(2*4)+2 = 12  /Ich gehe erst die vollen Zeilen durch, dann die Position in der Zeile
                                                             //!Zeilen und Spalten beginnen bei 0 (Array syntax)!
-    return matrix.space[memoryspace];                       //Gibt den Matrixwert an der ausgerechnenten Stelle zurück / ![] für Arraywert!
+    return matrix.buffer[memorybuffer];                       //Gibt den Matrixwert an der ausgerechnenten Stelle zurück / ![] für Arraywert!
 }
 
 
@@ -86,7 +86,7 @@ Matrix add(const Matrix matrix1, const Matrix matrix2){
 
 
     // Prüfen, ob beide Matrizen Speicher besitzen
-    if(matrix1.space == NULL || matrix2.space == NULL){
+    if(matrix1.buffer == NULL || matrix2.buffer == NULL){
         fprintf(stderr, "Error, one or more matrices without memory...\n");
         return summatrix;
     }
@@ -120,7 +120,7 @@ Matrix add(const Matrix matrix1, const Matrix matrix2){
     //Ergebnismatrix mit der richtigen Dimmension erstellen
     summatrix = createMatrix(matrix1.rows, resultcols);
 
-    if(summatrix.space == NULL){                                    //Prüfen ob Matrix erfolgreich erstellt wurde
+    if(summatrix.buffer == NULL){                                    //Prüfen ob Matrix erfolgreich erstellt wurde
         fprintf(stderr, "Error, memory allocation failed...\n");
         return summatrix;
     }
@@ -150,7 +150,7 @@ Matrix add(const Matrix matrix1, const Matrix matrix2){
             }
 
             // Werte addieren und speichern
-            summatrix.space[(i * summatrix.cols) + j] = value1 + value2;    //Wert in neue matrix eintragen/!Erklärung von [(i* summatrix.cols) + j] in "getMatrixAt"!
+            summatrix.buffer[(i * summatrix.cols) + j] = value1 + value2;    //Wert in neue matrix eintragen/!Erklärung von [(i* summatrix.cols) + j] in "getMatrixAt"!
         }
     }
 
@@ -169,7 +169,7 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2){
     Matrix multmatrix = {0, 0, NULL};
 
     // Prüfen, ob beide Matrizen Speicher besitzen
-    if(matrix1.space == NULL || matrix2.space == NULL){
+    if(matrix1.buffer == NULL || matrix2.buffer == NULL){
         fprintf(stderr, "Error, one or more matrices without memory...\n");
         return multmatrix;
     }
@@ -186,7 +186,7 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2){
     //Ergebnismatrix mit der richtigen Dimmension erstellen
     multmatrix = createMatrix(matrix1.rows, matrix2.cols);
 
-    if(multmatrix.space == NULL){                                    //Prüfen ob Matrix erfolgreich erstellt wurde
+    if(multmatrix.buffer == NULL){                                    //Prüfen ob Matrix erfolgreich erstellt wurde
         fprintf(stderr, "Error, memory allocation failed...\n");
         return multmatrix;
     }
@@ -205,7 +205,7 @@ Matrix multiply(const Matrix matrix1, const Matrix matrix2){
                 summe = summe + (getMatrixAt(matrix1, i, k) * getMatrixAt(matrix2, k, j));
             }
 
-            multmatrix.space[(i * multmatrix.cols) + j] = summe;
+            multmatrix.buffer[(i * multmatrix.cols) + j] = summe;
         }
     }
 

Startcode/matrix.h

@@ -9,15 +9,15 @@ typedef float MatrixType;
 typedef struct{
     unsigned int rows;      //Zeilen
     unsigned int cols;      //Spalten
-    MatrixType *space;      //Speicherbereich
+    MatrixType *buffer;      //Speicherbereich
 
 } Matrix;
 
-//[*space]                                                          |Zeile 1|  |Zeile 2|  |...
+//[*buffer]                                                          |Zeile 1|  |Zeile 2|  |...
 //           Ich wähle hier eine ein eindimensionales Array (ptr -> |0|1|2|3|  |4|5|6|7|  |8|9|...) Das ist einfacher zur speicherakolisierung mit malloc, weil ich nur einen Speicher reservieren muss
 //           ! man muss rechnen um auf die richtige Adresse zu kommen!
 //
-//[**space]
+//[**buffer]
 //           Würde man das wählen hätte ich ptr -> |ptr|ptr|ptr|, jeder dieser pointer würde dann auf eine Zeile Zeigen
 //           !Ich müsste alle malloc nacheinander löschen (schwieriger)!