Exemple de programme C démontrant l'utilisation de tableaux de longueur variable

Supposons que nous soyons responsables de la construction d'un système de bibliothèque pour surveiller et interroger diverses opérations de la bibliothèque. Il nous est maintenant demandé d'implémenter trois commandes différentes qui effectuent les opérations suivantes :

• En utilisant la commande 1, nous pouvons enregistrer l'insertion d'un livre avec y pages sur l'étagère x.

• En utilisant la commande 2, nous pouvons imprimer le numéro de page du septième livre sur l'étagère x.

• En utilisant la commande 3, nous pouvons imprimer le nombre de livres sur l'étagère x.

Ces commandes sont données sous la forme d'un tableau 2D au format {type de commande, x, y}. S'il n'y a pas de valeur y, la valeur par défaut est 0. Nous imprimons le résultat de la commande donnée.

Donc, si l'entrée est la suivante : Nombre d'étagères = 4, Nombre de requêtes = 4, Tableau d'entrée = {{1, 3, 23}, {1, 4, 128}, {2, 3, 0} , {3, 4 ,0}} ; alors le résultat sera

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.

Pour résoudre ce problème, nous suivrons les étapes suivantes :

• b := Nouveau tableau de taille s
• p := Nouveau tableau de taille s
• Initialisation i := 0, quand i < s, mettre à jour (augmenter i 1), effectuer les opérations suivantes :
  • b[i] := 0
  • p[i] := Nouveau tableau
• Initialisez loopCount := 0, lorsque loopCount < q, mettez à jour (augmentez loopCount 1), effectuez les opérations suivantes −
  • qtype := q_array[loopCount, 0]
  • Si qtype est identique à 1, alors −
    • x := q_array[loopCount, 1]
    • y := q_array[loopCount, 2]
    • b[x] := b[x] + 1
    • p[x] := Libère l'objet pointé par p[x ] et renvoie la taille de
    • b [x]
    • p[x, b[x] - 1] = y
  • Sinon, lorsque qtype est identique à 2, alors −
    • x := q_array[ loopCount, 1]
    • y := q_array[loopCount, 2]
    • Imprimer p[x, y]
  • Sinon
    • x := q_array[loopCount, 1]
    • Imprimer b[x]
• Si b n'est pas vide, alors −
  • Libérez la mémoire acquise par b
• Initialisez i := 0, quand i < p[i] n'est pas vide, alors −
  • Libère la mémoire acquise par p[i]
    Si p n'est pas vide, alors −
  • Libère la mémoire acquise par p
Exemple

Regardons l'implémentation suivante pour mieux comprendre −

#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);
}

input

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

output

23
1

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!