Was mache ich falsch mit pointer, array

[David O. (antimonit)]

Hallo, ich verstehe nicht warum mein Programm zur Berechnung von 
Matrizen, keine größere Zeilenanzahl als 4 zulässt, ab zeile = 5 stürzt 
das Programm immer ab. Bei Zeilenwerten unter 5 funktioniert alles 
einwandfrei.
Über eine Antwort würde ich mich sehr freuen:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define nl printf("\n");

//Hier werden der Matrix Werte übergeben(und hier ist wohl auch der Fehler:
void init(int **matrix, int zeile, int spalte){
  int zahl, eingabe, i, k;
  printf("Jeden Wert einzeln(0), oder nur mit einem einigen Wert initialisieren(1)"); nl
  scanf("%d", &eingabe);
  
//Jede Zahl einzeln initialisieren:
  if(eingabe==0){
    printf("Initialisiere die Matrix:"); nl
    for(i=0; i<zeile; i++ ){
      for(k=0; k<spalte; k++)  {
      scanf("%d", &zahl);
      matrix[i][k]=zahl;
      }
    }
//Mit nur einen Zahl initialisieren:
  }else{
    printf("Welche Zahl?"); nl
    scanf("%d", &zahl);
    for(i=0; i<zeile; i++ ){
      for(k=0; k<spalte; k++)  {
        matrix[i][k]=zahl;
//        printf(" %d ", i);        KOntrolle von i, mit dem Ergnis, das es gar nicht alle Spalten der 5. Zeile abgearbeitet werden
//        *(*(matrix+i)+k)=zahl;      Alternativschreibweise
      }
    }
  }
}
//Hier bekommen alle Werte einer Matrix den Wert 0:
void init_zero(int **matrix, int zeile, int spalte){
  int i, k;
  for(i=0; i<zeile; i++ ){
    for(k=0; k<spalte; k++)  {
    
    matrix[i][k]=0;
    }
  }
}
//Hier wird die Matrix ausgegeben:
printm(int **matrix, int zeile, int spalte){
  int i, k;
  
  for(i=0; i<zeile; i++ ){
    for(k=0; k<spalte; k++)  {
    printf("%d\t", matrix[i][k]);  
    }
    nl
  }
}
//Hier werden der Matrix Zufallswerte übergeben:
void init_random(int **matrix, int zeile, int spalte){
  int zahl, i, k;
  time_t t;
     srand((unsigned) time(&t));
     zahl=rand()%10;
  for(i=0; i<zeile; i++ ){
    for(k=0; k<spalte; k++)  { 
    zahl=rand()%10;
    matrix[i][k]=zahl;
    }
  }
}

//Hier bekommt die Matrix die Anzahl der Zeilen und Spalten:
int ** structm(int **matrix, int zeile, int spalte){

  int i;
  matrix=malloc(zeile*sizeof(int));
  if(matrix==NULL){
  printf("kein Speicherplatz vorhanden"); nl
  return 0;
  }  
  
  for(i=0; i<zeile; i++){
    matrix[i]=malloc(spalte*sizeof(int));
    if(matrix[i]==NULL){
  printf("kein Speicherplatz vorhanden"); nl
  return 0;      
    }
  }
  return matrix;
}
//Hier werden die 2 Matrizen multipliziert:
int multi(int **matrix, int **matrix2, int spalte, int zeile, int spalte2, int zeile2, int **result){
  if(spalte!=zeile2){
    printf("keine Multiplikation möglich");
    return 0;
    }

    int i, k, l;

    for (i = 0; i < zeile; i++) {  
        for (k = 0; k < spalte2; k++) {    
            for (l = 0; l < zeile2; l++) {  
                result[i][k] += matrix[i][l] * matrix2[l][k];  
            } 
    }
  }
  printm(result, zeile, spalte2);
  
  
  return 0;
}


int main(int argc, char *argv[]) {
  int spalte=0, zeile=0 , i;
  int spalte2=0, zeile2=0;
  int  **matrix;
  int  **matrix2;
  
  printf("Gebe die Spalten- und Zeilenanzahl ein:"); nl
  scanf("%d %d", &spalte, &zeile );
/*
  matrix=malloc(zeile*sizeof(int));
  if(matrix==NULL){
  printf("kein Speicherplatz vorhanden"); nl
  return 0;
  }  
  
  for(i=0; i<zeile; i++){
    *(matrix+i)=malloc(spalte*sizeof(int));
    if(matrix[i]==NULL){
  printf("kein Speicherplatz vorhanden"); nl
  return 0;      
    }
  }
*/  

//Abarbeitung der ersten Matrix
  matrix=structm(matrix, zeile, spalte);
  init(matrix, zeile, spalte);
  printm(matrix, zeile, spalte);
  nl
  
//Abarbeitung der zweiten Matrix  
  printf("Gebe die Spalten- und Zeilenanzahl ein:"); nl
  scanf("%d %d", &spalte2, &zeile2 );
  
  matrix2=structm(matrix2, zeile2, spalte2);
//  init_random(matrix2, zeile2, spalte2);
  init(matrix2, zeile2, spalte2);
  printm(matrix2, zeile2, spalte2);
  
  
//Multiplikationsmatrix
  int **result;
  result= structm(result, zeile, spalte2);
  init_zero(result, zeile, spalte2);
  
//  Multilpikation
  multi(matrix, matrix2, spalte, zeile, spalte2, zeile2, result);
  
  
  
  return 0;
}

Gruß
Antimonit

--

Bitte C-Quelltext in [ c ] [ /c ] einschließen.

-rufus

[Rufus Τ. F. (rufus)]

//Hier bekommt die Matrix die Anzahl der Zeilen und Spalten:
int ** structm(int **matrix, int zeile, int spalte){

  int i;
  matrix=malloc(zeile*sizeof(int));
  if(matrix==NULL){
  printf("kein Speicherplatz vorhanden"); nl
  return 0;
  }  
  
  for(i=0; i<zeile; i++){
    matrix[i]=malloc(spalte*sizeof(int));
    if(matrix[i]==NULL){
  printf("kein Speicherplatz vorhanden"); nl
  return 0;      
    }
  }
  return matrix;
}

>   matrix=malloc(zeile*sizeof(int));


Das ist Murks. matrix ist kein int*, sondern ein int**, also ist hier 
sizeof int nur dann zufälligerweise korrekt, wenn sizeof int == sizeof 
int* ist.

Warum übergibst Du der Funktion den Parameter "matrix"? Was erhoffst Du 
Dir davon?


> #define nl printf("\n");


Gewöhn Dir das gleich wieder ab. Du kannst auch einfach \n an Deine 
Ausgaben anhängen, so, wie es der Rest der Welt auch macht.

[David O. (antimonit)]

Okay, klingt einleuchtend, aber wie würde es dann korrekt aussehen?
Den Parameter "matrix" übergebe ich weil ich der Matrix Speicher 
zuweisen will.

Ist denn der Rest mit dem "int **matrix"(zum Beispiel bei den 
Funktionen) richtig, oder ist bei mir alles eher zufällig geglückt...für 
bestimmte Werte.

Okay, danke für den Hinweis beim "nl".

[Rufus Τ. F. (rufus)]

David O. schrieb:
> Den Parameter "matrix" übergebe ich weil ich der Matrix Speicher
> zuweisen will.

Da Du die Variable mit dem Rückgabewert der Funktion überschreibst, geht 
das gut, aber es ist überflüssig und nutzlos, das als Parameter zu 
übergeben.

Wolltest Du tatsächlich den übergebenen Parameter verändern, müsstest Du 
a) den Rückgabewert der Funktion nicht an matrix zuweisen und b) einen 
Pointer auf matrix übergeben und den innerhalb Deiner Funktion 
dereferenzieren:

//aufruf

int** mm;

if (!structm(&mm, 3, 4))
{
  //fehlerbehandlung
}




//Hier bekommt die Matrix die Anzahl der Zeilen und Spalten:
int ** structm(int ***matrix, int zeile, int spalte)
{
  int i;

  *matrix = malloc(zeile * sizeof (int*));
  if (*matrix == NULL)
  {
    printf("kein Speicherplatz vorhanden\n");
    return 0;
  }  
  
  for (i = 0; i < zeile; i++)
  {
    *matrix[i] = malloc(spalte * sizeof (int));
    if (*matrix[i] == NULL)
    {
      printf("kein Speicherplatz vorhanden\n");
      return 0;      
    }
  }
  return *matrix;
}

Der Rückgabewert hat hier keinen weiteren Gebrauchswert als daß er im 
Erfolgsfall nicht 0 ist, was beim Aufruf entsprechend ausgewertet werden 
kann. Du könntest die Funktion daher auch irgendeinen anderen Typen als 
int** zurückgeben lassen, ein einfacher int würde reichen, der 0 bzw. 1 
annimmt.

Findest Du nicht auch, daß ein paar Leerzeichen den Code lesbarer 
machen?

[David O. (antimonit)]

Rufus Τ. F. schrieb:
> Da Du die Variable mit dem Rückgabewert der Funktion überschreibst, geht
> das gut, aber es ist überflüssig und nutzlos, das als Parameter zu
> übergeben.
>
> Wolltest Du tatsächlich den übergebenen Parameter verändern, müsstest Du
> a) den Rückgabewert der Funktion nicht an matrix zuweisen und b) einen
> Pointer auf matrix übergeben und den innerhalb Deiner Funktion
> dereferenzieren:

Ja, danke, das stimmt...

Hab die Korrektur jetzt mal eingefügt(In der Funktion structm), jetzt 
geht allerdings gar nicht mehr, wo also hängts bei mir noch, der Rest 
sieht meiner Meinung nach richtig aus....bzw ich raff es nicht...

Rufus Τ. F. schrieb:
> Findest Du nicht auch, daß ein paar Leerzeichen den Code lesbarer
> machen?

Ja, da ist schon was dran :)

[Rolf M. (rmagnus)]

Rufus Τ. F. schrieb:
> *matrix = malloc(zeile * sizeof (int*));

Ich würde den Compiler selber den richtigen Typ finden lassen:

*matrix = malloc(zeile * sizeof **matrix);

>     *matrix[i] = malloc(spalte * sizeof (int));
>     if (*matrix[i] == NULL)

Das müßte heißen:

    (*matrix)[i] = malloc(spalte * sizeof (int));
    if ((*matrix)[i] == NULL)

[Rufus Τ. F. (rufus)]

Rolf M. schrieb:
> Ich würde den Compiler selber den richtigen Typ finden lassen:

Das ist wartungsfreundlicher. Punkt für Dich.

> Das müßte heißen:

Du hast natürlich auch hier recht.

Alternativ könnte man schreiben

matrix->[i] = malloc(...)

aber das würde vermutlich wieder Leute auf die Barrikaden bringen, die C 
unlesbar finden.

[David O. (antimonit)]

Danke für die Hinweise, nur stürzt das Programm immer noch direkt nach 
der Eingabe von Zeile und Spalte ab.

[David O. (antimonit)]

Problem gelöst: Es hätte bei der ersten Allokierung:

  matrix=(int **)malloc(zeile*sizeof(int*));

heißen müssen.
Dann funktioniert es für alle Werte.
Großes Dankeschön für die Hilfe und die Hinweise.

[Yalu X. (yalu) (Moderator)]

Rufus Τ. F. schrieb:
> matrix->[i] = malloc(...)

Gaht das? Ich glaube nicht. Den "->"-Operator kann man in C doch nur auf
einen Struct-Pointer anwenden.

Rufus Τ. F. schrieb:
> aber das würde vermutlich wieder Leute auf die Barrikaden bringen, die C
> unlesbar finden.

Dafür wäre evtl. Folgendes ganz gut geeignet:

  i[*matrix] = malloc(...);

Damit spart man sich die runden Klammern in

  (*matrix)[i] = malloc(...);

was den Code deutlich kürzer und übersichtlicher macht ;-)

[Rolf M. (rmagnus)]

Yalu X. schrieb:
> Rufus Τ. F. schrieb:
>> matrix->[i] = malloc(...)
>
> Gaht das? Ich glaube nicht.

Ich auch nicht. a->b ist die Entsprechung von (*a).b. Aber (*matrix).[i] 
ergibt keinen Sinn. Damit ergibt auch matrix->[i] keinen.

[Mikro 7. (mikro77)]

Yalu X. schrieb:
> Dafür wäre evtl. Folgendes ganz gut geeignet:
>
>

>   i[*matrix] = malloc(...);
>

>
> was den Code deutlich kürzer und übersichtlicher macht ;-)

Könnte bei denen für Verwirrung sorgen die nicht wissen dass:
a[i] == *(a+i) == *(i+a) == i[a] ist. ;-)