Probleme beim lesen der Matrix Elemente



  • Hallo Forum,

    Ich versuche zur Zeit in C zu programmieren, habe leider weder Erfahrung noch das Auge für Fehler.

    Konkret:
    Ich will die Determinante von Matrizen ausrechnen und will zunächst eine 2x2 Matrix anschauen. Leider wird immer nur die letzte Zeile erkannt, die aber dafür mehrfach.
    Ich habe natürlich bereits gegoogelt, allerdings bin ich nicht unbedingt schlauer geworden. Eher das Gegenteil, da für mich das Einlesen der Matrix gleich aussieht.

    Hier mein Code: (soll noch ausgebaut werden)

    #include <math.h>
    #include <stdio.h>
    #include <time.h>
    
    int main()
    {
    int det, n, i=0, j=0; /*n für die Dimension der Matrix ,i=Zeile und j=Spalte*/
    int matrix[i][j]; /*Matrix als Array*/
    
    printf("Welche Dimension soll die Matrix haben? \n");
    scanf("%d",&n);
    printf("Matrix der Form %d x %d wird erstellt. \n", n, n);
    printf("Bitte geben sie die Werte der Matrix ein. \n \n");
    for(i=0; i < n; i++)
    	{
    	for(j=0; j < n; j++)
    		{
    		scanf("%d", &matrix[i][j]);
    		};
    	};
    
    if(n==2)
    	{
    	det= matrix[0][0]*matrix[1][1]-matrix[1][0]*matrix[0][1];
    	}
    
    printf("Determinante: %d \n", det);
    for(i=0; i<n; i++)
    	{
    	for(j=0; j<n; j++)
    		{
    		printf("Inhalt von Eintrag [%d][%d]", i, j);
    		printf("ist %d \n", matrix[i][j]);
    		}
    	}
    
    return 0;
    }
    

    Ich will die Lösung nicht unbedingt, allerdings würde ich sehr gerne erfahren, wo mein Fehler liegt 😃
    Ich bin dankbar für jegliche Hilfe!

    Grüße
    IcC



  • Welche Größe hat deine in Zeile 8 definierte Matrix?
    VLA (so wie du in Zeile 😎 benutzen nur Deppen.



  • Und wieder sind alles Deppen die es einfach nicht besser wissen



  • @TocToc Diese Konstruktion ist aber wirklich übel :D.
    Mach das VLA weg und nutze malloc, dann musst du die Größe das Arrays auch nicht in jedem Schleifendurchlauf ändern.
    Und die ';' hinter den geschweiften Klammern kannst du weglassen. Es sieht so aus als hättest du Teile des Codes von irgendwo kopiert, so wird das nichts.


  • Mod

    TocToc schrieb:

    Und wieder sind alles Deppen die es einfach nicht besser wissen

    Wir wissen mittlerweile, dass dir der Ton hier nicht gefällt. Das musst du nicht in jedem Thread kund tun. Bitte nur Beiträge zur Sache.



  • Hi,

    wäre ich kein Depp, würde ich wohl kaum diese Frage hier stellen.

    Die Größe der Matrix soll nicht von Vornherein fest stehen. Ob VLA oder nicht ist für mich momentan zweitrangig.

    Welchen Vorteil hat malloc gegenüber VLA? Vor allem, wenn ich eigentlich die Größe der Matrix tatsächlich während einer Schleife ändern will.

    Keine Ahnung wieso ich nach den geschweiften Klammern ein Semicolon gesetzt habe. 😕
    Aber nein, ich habe nichts kopiert, weil, wie du es schon erwähnt hast, es sonst nichts wird.

    Danke erstmal dafür!

    Grüße
    IcC



  • Und ausserdem wollte Wutz ihn damit sicherlich nicht angreifen, sondern nur deutlich machen das man VLA eben nicht verwendet.
    Mir kommt es so vor als ob TocToc die Beiträge gezielt danach durchsucht vielleicht um sein Profil zu pushen.



  • VLA werden (wie bei allen automatischen Variablen) auf dem Stack angelegt.
    Bei malloc wird der Speicher von Heap geholt. (*)

    Der Stack ist (wesentlich) kleiner als der Heap.
    Darum ist es eine blöde Idee, den Stackverbrauch von Nutzereingaben abhängig zu machen.

    VLA wurden in C mit dem Standard von 1999 eingeführt - und mit dem von 2011 wieder frei gestellt.

    (*) sofern es einen gibt. Aber dann hat man eh andere Probleme.



  • Der Vorteil ist, dass du die Größe in der Schleife dann nicht mehr ändern musst.
    Die Matrix wird nie größer als n*n, also reserviere mit malloc soviel.



  • Mir kommt es so vor als ob TocToc die Beiträge gezielt danach durchsucht vielleicht um sein Profil zu pushen.

    Was hätte ich davon? Nix. Nö, mir geht es schlichtweg darum, dass ich das ziemlich krass finde wie hier in DIESEM Teil des Forums miteinandergeredet wird.


  • Mod

    Wenn man VLAs benutzt, dann ist dies hier tatsächlich eine sehr gute Gelegenheit dafür. Aber eben nicht so wie es hier gemacht wurde! Was wir wollen, ist das VLA auf den Heap zu legen. Dadurch haben wir die schicke Syntax der VLAs ohne deren gefährliche Seiten. Im Endeffekt können wir dadurch den Rest des Programms unverändert lassen und haben trotzdem alles dynamisch:

    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
      size_t n;
      printf("Welche Dimension soll die Matrix haben? \n");
      scanf("%zu",&n);
    
      printf("Matrix der Form %zu x %zu wird erstellt. \n", n, n);
      int (*matrix)[n] = malloc(sizeof(*matrix)*n);
    
      printf("Bitte geben sie die Werte der Matrix ein. \n \n");
      for(size_t i=0; i < n; i++)
        {
          for(size_t j=0; j < n; j++)
            {
              scanf("%d", &matrix[i][j]);
            }
        }
    
      if(n==2)
        {
          int det= matrix[0][0]*matrix[1][1]-matrix[1][0]*matrix[0][1];
          printf("Determinante: %d \n", det);
       }
    
      for(size_t i=0; i<n; i++)
        {
          for(size_t j=0; j<n; j++)
            {
              printf("Inhalt von Eintrag [%zu][%zu] ", i, j);
              printf("ist %d \n", matrix[i][j]);
            }
        }
    
      free(matrix);
    }
    

Log in to reply