creat eine multdimentional array zu speichern viele arrays unterschiedlicher Größe in C

Ich fragte diese Frage, aber ich habe es gelöscht, weil nicht klar war. Ich habe drei Schleifen, die produzieren, 0, 1 Daten. Ich möchte Sie zu speichern, wie eine matrix, also ich denke es sollte gespeichert werden, in ein mehrdimensionales array, das nenne ich Third.

for (i=0; i<m; i++) {
    for (int l = 0; l < n2; ++l) {
        for (x = 0; x < all[i].n; ++x) {
            f = (int)VECTOR(v2)[l];
            if(a[x].vto == f) {
                printf("%d",1);
            } else {
                printf("%d",0);
            }
        }
    }
    for (int y = 0; y < n1; ++y) {
        for (x = 0; x < all[i].n; ++x) {
            q = (int)VECTOR(v1)[y];
            if(a[x].vfrom == q) {
                printf("%d",1);
            } else {
                printf("%d",0);
            }
        }
    }
    printf("\n");  
}

Das gedruckte Ergebnis aus dem vorherigen code ist, und ich möchte, um es zu speichern die auf diesem Formular:

100010001111
111000000111100100010010001001
111000000000111000000000111100100100010010010001001001
110000001100000011101010010101
111100010001

Mein Ziel ist, speichern Sie das gedruckte Ergebnis in ein array wie

Third = = [ [[100][010][001][111]] [[111000][000111][100100][010010][001001]]...[[111][100][010][001]]

also, wenn ich will, um den Zugriff auf das array Third ich tun, Third[3] = [ [110000] [001100] [000011] [101010] [010101] ] oder Third[3][1] = [001100] oder Third[3][1][2] = 1.

Ich würde sehr glücklich sein, zu klären, was nicht klar ist. Danke für die Hilfe

EDIT 1: Der code ist zu groß, um Hinzugefügt werden, komplett. Ich fragte nach der Allgemeinen Art und Weise zu erreichen, was ich Suche, das ist, wie zu konstruieren ist ein mehrdimensionales array, oder ein array von arrays zum speichern von Daten, die Ergebnisse von drei verschachtelten Schleifen (nicht nötig, meine loops). Ich befestigte den aktuellen code, so jetzt das array Third enthält alle Daten, aber ich glaube nicht, dass dies der richtige Weg ist, die Daten zu speichern, um später darauf zugreifen als Third[3] = [ [110000] [001100] [000011] [101010] [010101] ]

Hier ist was ich getan habe:

  int second[n1+n2][n1*n2];
  int first[n1*n2];
  int Third[m][n1+n2][n1*n2];

for (i=0; i<m; i++) {
  Data * a = all[i].datas;
  igraph_edge(&graph, i, &from, &to);
  igraph_neighbors(&graph, &v1, from, IGRAPH_ALL);
  igraph_neighbors(&graph, &v2, to, IGRAPH_ALL);

  int n2 = igraph_vector_size(&v2);
  int n1 = igraph_vector_size(&v1);
  int f, q, x, l, y;




      for (l = 0; l < n2; ++l) {
        for (x = 0; x < all[i].n; ++x) {
                    f = (int)VECTOR(v2)[l];
                        if(a[x].vto == f) {
                                           first[x]=1;
                        } else {
                                            first[x]=0;
                          }
                    second[l][x] = first[x];
                    Third[i][l][x]  = second[l][x]; 
                    printf("%d", Third[i][l][x]); 
         }
       }

          for (y = 0; y < n1; ++y) {
              for (x = 0; x < all[i].n; ++x) {
                  q = (int)VECTOR(v1)[y];
                        if(a[x].vfrom == q) {
                                              first[x]=1;
                         } else {
                                              first[x]=0;
                           }
                                        second[y+n2][x] = first[x];
                                        Third[i][y+n2][x]  = second[y+n2][x];
                                        printf("%d", Third[i][y+n2][x]); 
                }
           }
         printf("\n");  
    }

beim kompilieren des obigen Codes bekomme ich

100010001111
111000000111100100010010001001
111000000000111000000000111100100100010010010001001001
110000001100000011101010010101
111100010001

Ich bin mir nicht sicher, ob dies der richtige Weg, es zu tun?Dank

EDIT 2:

Ich Frage mich, ob die Erklärung in dieser Art und Weise, wie unten richtig ist oder nicht? Ist die drei-dimensionale array Third Feste Größe oder ist es (wie erforderlich) dynamische nach n1 und n2, die sich ändern, je nach der iteration von i ist.

  int second[n1+n2][n1*n2];
  int first[n1*n2];
  int Third[m][n1+n2][n1*n2];


  for (i=0; i<m; i++) {
  Data * a = all[i].datas;
  igraph_edge(&graph, i, &from, &to);
  igraph_neighbors(&graph, &v1, from, IGRAPH_ALL); //initialize the vector v2 where it's values and it's size vary depending on i
  igraph_neighbors(&graph, &v2, to, IGRAPH_ALL); //initialize the vector v2 where it's values and it's size vary depending on i

  int n2 = igraph_vector_size(&v2); // the size changes depending on i, i.e the change from an iteration to another
  int n1 = igraph_vector_size(&v1); // the size changes depending on i, i.e the change from an iteration to another
  int f, q, x, l, y;


      for (l = 0; l < n2; ++l) {
        for (x = 0; x < all[i].n; ++x) {
                    f = (int)VECTOR(v2)[l];
                        if(a[x].vto == f) {
                                           first[x]=1;
                        } else {
                                           first[x]=0;
                          }
                    second[l][x] = first[x];
                    Third[i][l][x]  = second[l][x]; 
         }
      }
   }

1 Antworten

  • Cacahuete Frito
    3. Mai 2019

    Sie möchten dieses:

    Third = [ [[100][010][001][111]] [[111000][000111][100100][010010][001001]]...[[111][100][010][001]] ];

    Ich gehe davon aus, dass die Art der Daten, die Sie wollen, ist bool, aber könnte sein.

    Dies kann nicht erreicht werden, genau in C, alle die Elemente in einem array müssen vom gleichen Typ sein, und das beinhaltet, seine Größe, wenn wir reden über arrays.

    Option 1:

    Aber wir haben zum Beispiel *argv[], die ein array von Zeigern, aber wie Pointer Verhalten sich wie arrays, die wir effektiv haben, so etwas wie dies (nach der gleichen Grammatik):

    *argv[] = [ [program\0][arg1\0][arg2\0] ]

    Etwas ähnliches wie das, was Sie wollen könnte:

    void *third[n];

    Und vorausgesetzt, Sie haben alle Ihre zweite arrays definiert als

    bool second_0[4][3];
bool second_1[5][6];
...
bool second_n[4][3];

    Dann können Sie beitreten, Sie alle in third wie diese:

    third[0] = &second_0;
third[1] = &second_1;
...
third[n] = &second_n;

    Und Sie könnte bei der Verwendung von third wie diese: lassen Sie uns sagen, Sie wollen zu extrahieren-element [i][j][k] in eine temporäre variable, und lassen Sie uns davon ausgehen, dass das array second_i hat Größen second_i[n][m]:

    bool tmp = (*(bool (*)[n][m])third[i])[j][k];

    Die Verwendung ist nicht sehr schön, aber es ist die nächste Sache, die Sie haben können, was Sie wollen.

    Option 2 (bevorzugt):

    Sie können einen großen array wie dieses: bool third[100][20][30]; die halten kann immer mehr zahlen als Ihre größte erwartete zweite array hat, und lassen Sie einfach als 0 der ungenutzten Werte. Es wird mehr Speicher verwenden, aber Sie brauchen keine Typumwandlungen oder Zeiger, und wird viel schneller sein als alle der Speicher zusammenhängend sein.

    Wenn Sie diese option verwenden, müssen Sie eine zusätzliche variable

    ptrdiff_t third_sizes[ARRAY_SIZE(third)][2];

    zum speichern der Größen der jeweils zweiten Reihe, so dass Sie nachverfolgen können, welcher Teil, die Sie verwendet haben (mit der ersten option müssten Sie es auch). ARRAY_SIZE() definiert werden sollte, wie diese:

    #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))