Array [] ... /* Matrizenmultiplikation */

  • Array [] ... /* Matrizenmultiplikation */

    Quellcode

    1. /* MATRIX * VEKTOR */
    2. /* Matrizenmultiplikation */
    4. #include <stdio.h>
    5. #include <stdlib.h>
    7. void einlesen(unsigned *a, unsigned n);
    8. void ausgabe(unsigned *y, unsigned n);
    9. double mult(unsigned *a, unsigned *x,unsigned *y, unsigned n);
    10. void Vekein(unsigned *x, unsigned n);
    12. int main()
    13. {
    14. unsigned *a, *x, *y; /* Zeiger auf Matrizen */
    15. unsigned n; /* Anzahl der Zeilen/Spalten */
    16. printf("Anzahl der Zeilen/Spalten: ");
    17. scanf("%d", &n);
    19. a = (unsigned *) calloc (n*n, sizeof(unsigned));
    20. x = (unsigned *) calloc (n*n, sizeof(unsigned));
    21. y = (unsigned *) calloc (n*n, sizeof(unsigned));
    24. printf("Erste Matrix einlesen\n");
    25. einlesen(a,n);
    26. printf("\nVektor einlesen\n");
    27. Vekein(x,n);
    29. mult(a, x,y, n);
    31. ausgabe (y,n);
    32. free(a);
    33. free(x);
    34. free(y);
    35. return 0;
    38. }
    40. void einlesen(unsigned *a, unsigned n)
    41. { int i,j;
    43. for (i=0; i<n; i++)
    44. {
    45. for (j=0; j<n; j++)
    46. scanf("%u", a+i*n+j); // i Zeile , j Spl.
    47. }
    48. }
    49. void Vekein(unsigned *x, unsigned n)
    50. { int i;
    51. for (i=0; i<n; i++)
    52. scanf("%u", &x[i]);
    53. }
    56. double mult(unsigned *a, unsigned *x, unsigned *y, unsigned n)
    57. { unsigned i, j, k;
    59. for (i = 0; i < n; i++)
    60. for (j = 0; j < n; j++)
    61. { y[i] = 0;
    62. for (k = 0; k < n; k++)
    63. y[i] += *(a+i*n+k) * x[k];
    64. }
    65. return y[i];
    66. }
    68. void ausgabe(unsigned *y, unsigned n)
    69. {
    70. unsigned i;
    72. printf("\nErgebnis:\n");
    73. for (i=0;i<n;i++)
    74. printf("\n %u \n", y[i]);
    75. }
    Alles anzeigen

    #######################################################################################################################





    Quellcode

    1. /* Matrix * Matrix = Vektor.
    6. #include <stdio.h>
    8. #include <stdlib.h>
    12. void einlesen(unsigned *a, unsigned n);
    14. void ausgabe(unsigned *a, unsigned n);
    16. void mult(unsigned *a, unsigned *b, unsigned
    17. *c, unsigned n);
    25. /* Cpp */
    29. #include "global.h"
    31. void einlesen(unsigned *a, unsigned n)
    33. { int i,j;
    37. for (i=0; i<n; i++)
    39. {
    41. for (j=0; j<n; j++)
    43. scanf("%d", a+i*n+j);
    45. }
    47. }
    53. void ausgabe(unsigned *a, unsigned n)
    55. { unsigned i, j;
    59. for (i = 0; i < n; i++)
    61. { for (j = 0; j < n ; j++)
    63. printf("%u ", *(a+i*n+j));
    65. printf("\n");
    67. }
    69. // printf("\n");
    71. }
    79. void mult(unsigned *a, unsigned *b, unsigned
    80. *c, unsigned n)
    82. /* Multipiziert a mit b; Ergebnis in c
    83. */
    85. { unsigned i, j, k;
    89. for (i = 0; i < n; i++)
    91. for (j = 0; j < n; j++)
    93. {
    94. *(c+i*n+j) = 0;
    96. for (k = 0;
    97. k < n; k++)
    99. *(c+i*n+j) += *(a+i*n+k) * *(b+k*n+j); }
    101. }
    109. */ main.cpp*/
    115. #include "global.h"
    119. int main()
    121. {
    123. unsigned *a, *b, *c;
    124. /* Zeiger auf Matrizen */
    126. unsigned n;
    127. /* Anzahl der Zeilen/Spalten */
    131. printf("Anzahl der Zeilen/Spalten: ");
    133. scanf("%u", &n);
    137. a = (unsigned *) calloc (n*n, sizeof(unsigned));
    139. b = (unsigned *) calloc (n*n, sizeof(unsigned));
    141. c = (unsigned *) calloc (n*n, sizeof(unsigned));
    145. printf("Erste Matrix einlesen\n");
    147. einlesen(a,n);
    149. printf("\nZweite Matrix einlesen\n");
    152. einlesen(b,n);
    156. mult(a, b,
    157. c, n);
    159. printf("\nErgebnismatrix:\n");
    161. ausgabe(c,
    162. n);
    164. free(a);
    166. free(b);
    168. free(c);
    170. getchar();
    172. getchar();
    174. }
    184. Normal
    185. 0
    188. 21
    191. false
    192. false
    193. false
    195. DE
    196. X-NONE
    197. X-NONE
    Alles anzeigen

    ######################################################################################################################

    Quellcode

    1. /* Matrizenmultiplikation Matrix * Zahl */
    3. #include <stdio.h>
    4. #include <stdlib.h>
    6. void einlesen(unsigned *a, unsigned n);
    7. void ausgabe(unsigned *a, unsigned n);
    8. void mult(unsigned *a, unsigned *e,double z, unsigned n);
    10. int main()
    11. {
    12. unsigned *a,*e; /* Zeiger auf Matrizen */
    13. unsigned n; /* Anzahl der Zeilen/Spalten */
    14. double z;
    16. printf("Anzahl der Zeilen/Spalten: ");
    17. scanf("%u", &n);
    19. a = (unsigned *) calloc (n*n, sizeof(unsigned));
    20. e = (unsigned *) calloc (n*n, sizeof(unsigned));
    22. printf("Matrix einlesen\n");
    23. einlesen(a,n);
    25. printf("Geben Sie ein Vergroesserungsfaktor ein: "); // die Zahl
    26. scanf("%lf", &z);
    28. mult(a, e,z, n);
    30. printf("\nErgebnismatrix:\n");
    32. ausgabe(e, n);
    34. free(a);
    35. free(e);
    36. return 0;
    37. }
    39. void einlesen(unsigned *a, unsigned n)
    40. { int i,j;
    42. for (i=0; i<n; i++)
    43. {
    44. for (j=0; j<n; j++)
    45. scanf("%d", a+i*n+j);
    46. }
    47. }
    49. void ausgabe(unsigned *a, unsigned n)// Das musst du auswendig.
    50. { unsigned i, j;
    52. for (i = 0; i < n; i++)
    53. { for (j = 0; j < n ; j++)
    54. printf("%u ", *(a+i*n+j));
    55. printf("\n");
    56. }
    57. printf("\n");
    58. }
    60. void mult(unsigned *a, unsigned *e, double z, unsigned n)
    61. { unsigned i, j;
    62. for (i = 0; i < n; i++)
    63. for (j = 0; j < n; j++)
    64. { *(e+i*n+j) = 0;
    65. *(e+i*n+j) = *(a+i*n+j) * z;
    66. }
    67. }
    Alles anzeigen

  • hier mal damit du da etwas einordnen kannst:

    Quellcode

    1. Keyword Bytes Range
    2. char 1 -128 .. 127
    3. unsigned char 1 0 .. 255
    4. int
    5. unsigned = unsigned int
    6. double => double-precision floating-point

    Für int ist im C-Standard keine absolute Grösse zugeordnet.
    Es gilt: short <= int <= long
    Diese können je nach Compiler und Betriebssystem unterschiedlich gross sein. Beispiel: int kann 2 byte, 4 byte oder sonst eine Grösse haben. Wenn ihr die Grösse braucht, müsst ihr die im Programm ermitteln oder in den Unterlagen des Compilers nachsehen.

    Hier noch etwas Neueres für Grössen von Arrays, Matrizen und Ähnlichem:
    stackoverflow.com/questions/2550774/what-is-size-t-in-c


    Irgend wie sieht das so aus als wüsstest du nicht was "dein" Quelltext macht und deine Kommentare gehen auch in die Richtung. Aber für 3 Richtige im Lotto sollte dein Glück reichen, wenn man die Trefferquote im Quelltext sieht.

    Versuche den Quelltext besser zu formatieren. Dann kannst du den besser verstehen.

  • Keine Konflikte? ;)

    Gibt mal bei deinem letzten Beispiel-Quelltext:
    eine Matrix: 2_4_0_1 ein und einen Vergrösserungsfaktor von 3.8 und erkläre uns das Ergebnis. ;)

    Echt Windows 3.0? Schreib das doch sofort - zu der Zeit tickte C noch etwas anders.
    Wenn du es relativ einfach haben willst, vergiss die Windows vor 2000 bezüglich C.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von bcc-fan ()