C-Programmbeispiel, das die Verwendung von Arrays variabler Länge demonstriert

Angenommen, wir sind für den Aufbau eines Bibliothekssystems zur Überwachung und Abfrage verschiedener Vorgänge der Bibliothek verantwortlich. Jetzt werden wir gebeten, drei verschiedene Befehle zu implementieren, die die folgenden Operationen ausführen:

• Mit Befehl 1 können wir das Einfügen eines Buches mit y Seiten auf Bücherregal x aufzeichnen.

• Mit Befehl 2 können wir die Seitenzahl des y-ten Buches im Bücherregal x ausdrucken.

• Mit Befehl 3 können wir die Anzahl der Bücher im Bücherregal x ausdrucken.

Diese Befehle werden in Form eines 2D-Arrays mit dem Format {Befehlstyp, x, y} angegeben. Wenn kein y-Wert vorhanden ist, ist der Standardwert 0. Wir geben das Ergebnis des angegebenen Befehls aus.

Wenn die Eingabe also wie folgt lautet: Anzahl der Bücherregale = 4, Anzahl der Abfragen = 4, Eingabearray = {{1, 3, 23}, {1, 4, 128}, {2, 3, 0} , {3, 4 ,0}}; dann lautet die Ausgabe

23
1

Command 1 inserts a book with 23 pages on shelf 3.
Command 2 inserts a book with 128 pages on shelf 4.
Command 3 prints the page number of book 0 on shelf 3.
Command 4 prints the number of books on shelf 3.

Um dieses Problem zu lösen, führen wir die folgenden Schritte aus:

• b := Neues Array der Größe s
• p := Neues Array der Größe s
• Initialisierung i := 0, wenn i < s, aktualisieren (i 1 erhöhen), die folgenden Operationen ausführen:
  • b[i] := 0
  • p[i] := Neues Array
• Initialisieren Sie loopCount := 0, wenn loopCount < q, aktualisieren Sie (loopCount erhöhen) und führen Sie die folgenden Operationen aus: −
  • qtype := q_array[loopCount, 0]
  • Wenn qtype gleich 1 ist, dann −
    • x := q_array[loopCount, 1]
    • y := q_array[loopCount, 2]
    • b[x] := b[x] + 1
    • p[x] := Geben Sie das Objekt frei, auf das p[x zeigt ] und geben Sie die Größe von
    • b [x]
    • p[x, b[x] - 1] = y
  • zurück. Andernfalls, wenn qtype gleich 2 ist, dann −
    • x := q_array[ loopCount, 1]
    • y := q_array[ loopCount, 2]
    • Drucken Sie p[x, y]
  • Andernfalls
    • x := q_array[loopCount, 1]
    • Drucken Sie b[x]
• Wenn b nicht leer ist, dann −
  • Gib den von b erfassten Speicher frei
• Initialisiere i := 0, wenn i < s, aktualisiere (erhöhe i 1) und führe die folgenden Operationen aus −
  • Wenn p[i] ist nicht leer, dann −
    • Geben Sie den von p[i] erworbenen Speicher frei.
  • Wenn p nicht leer ist, dann −
    • Geben Sie den von p erworbenen Speicher frei
    Schauen wir uns zum besseren Verständnis die folgende Implementierung an –

    #include <stdio.h>
    #include <stdlib.h>
    
    void solve(int s, int q, int q_array[][3])
    {
          int* b;
          int** p;
       b = (int*)malloc(sizeof(int)*s);
       p = (int**)malloc(sizeof(int*)*s);
       for(int i = 0; i < s; i++)
       {
          b[i] = 0;
          p[i] = (int*)malloc(sizeof(int));
       }
       int loopCount;
       for(loopCount = 0; loopCount < q; loopCount++)
       {
          int qtype;
          qtype = q_array[loopCount][0];
          if (qtype == 1)
          {
             int x, y;
             x = q_array[loopCount][1];
                y = q_array[loopCount][2];
             b[x] += 1;
             p[x] = realloc(p[x], b[x]*sizeof(int));
             p[x][b[x] - 1] = y;
          }
          else if (qtype == 2)
          {
             int x, y;
             x = q_array[loopCount][1];
                y = q_array[loopCount][2];
             printf("%d</p><p>", p[x][y]);
          }
          else
          {
             int x;
             x = q_array[loopCount][1];
             printf("%d</p><p>", b[x]);
          }
       }
       if (b)
          free(b);
       for (int i = 0; i < s; i++)
          if (p[i])
             free(p[i]);
       if (p)
          free(p);
    }
    int main() {
       int input_arr[][3] = {{1, 3, 23}, {1, 4, 128}, {2, 3, 0}, {3, 4, 0}};
          solve(4, 4, input_arr);
    }

  Eingabe

  int input_arr[][3] = {{1, 3, 23}, {1, 4, 128}, {2, 3, 0}, {3, 4, 0}};
  solve(4, 4, input_arr);

Ausgabe

23
1

Das obige ist der detaillierte Inhalt vonC-Programmbeispiel, das die Verwendung von Arrays variabler Länge demonstriert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!