Le redimensionnement d'un tableau en C

Dire que j'ai affecté à un tableau comme ceci:

char* array[]={"This"};

Et puis plus tard, j'ai voulu attribuer tableau[ ] une nouvelle valeur, de sorte qu'il stocke "Ceci" et "Cela" est-il un moyen que je puisse changer la taille de la table de sorte qu'il pourrait tenir un nouveau numéro de valeurs?

Notez que vous avez déclaré un tableau à deux dimensions ici. Je ne suis pas sûr que c'était votre intention?
ce n'est pas un tableau en 2 dimensions (peut-être que la question a été changé après votre commentaire, mais avant de le modifier fenêtre fermée).
techniquement, vous avez raison. C'est un tableau de pointeurs sur des caractères, mais il est initialisé comme un tableau de pointeurs vers des chaînes de caractères (avec un seul élément.) Peut-être ce qu'il veut bien, c'est un peu difficile de la question.
Je pense que c'est ce qu'il veut (à l'exception du tableau de variables de ne pas faire ce qu'il veut). Il commence avec un tableau de pointeur (à "This"), plus tard, il veut un tableau de deux pointeurs (un à "This" et un à "That").
on dirait que vous avez raison 🙂

OriginalL'auteur Sam | 2012-10-16

  1. 8

    Non, vous ne pouvez pas modifier la taille d'un tableau. Vous pouvez utiliser un allouée dynamiquement la liste des char* au lieu et realloc() requis:

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

int main()
{
    char** array = malloc(1 * sizeof(*array));

    if (array)
    {
        array[0] = "This";

        printf("%s\n------\n", array[0]);

        char** tmp = realloc(array, 2 * sizeof(*array));
        if (tmp)
        {
            array = tmp;
            array[1] = "That";

            printf("%s\n", array[0]);
            printf("%s\n", array[1]);
        }

        free(array);
    }
    return 0;
}

    Voir la démo en ligne: https://ideone.com/ng00k.

    Vous pouvez utiliser un VLA, mais même si la taille du tableau peut varier lors de l'exécution, une fois que le tableau a été créé, vous ne pouvez pas modifier sa taille (jusqu'à ce qu'il a été détruit et recréé).

    OriginalL'auteur hmjd

  2. 2

    Il n'y a pas moyen de redimensionner un tableau. Vous pouvez simplement créer un nouveau tableau de taille 2, puis de copier toutes les données de la précédente à la nouvelle. realloc le fait pour vous avec la mémoire dynamique. La meilleure façon est d'utiliser des structures de données telles que LinkedLists ou Vectors qui vous pouvez trouver plus au sujet de en ligne.

    OriginalL'auteur Ben

  3. 1

    Vous ne pouvez pas redimensionner des objets d'ensemble.

    Vous devez allouer dynamiquement de la mémoire pour array et de l'étendre à l'aide de realloc. Exemple:

    size_t current_size = 0;

char **array = malloc((current_size + 1) * sizeof *array);
if (array)
{
  array[current_size++] = "This";
}
...
/**
 * If realloc cannot extend the buffer, it will return NULL and leave
 * the original buffer intact; however, if we assign NULL back to array,
 * we lose our handle to the original buffer, causing a memory leak, so
 * we assign the result to a temporary variable.
 */
char **tmp = realloc(array, (current_size + 1) * sizeof *array)
if (tmp)
{
  array = tmp;
  array[current_size++] = "That";
}
else
{
  //realloc failed to extend the buffer; original buffer
  //is left intact.
}

    Mises en garde:

    realloc est relativement cher appel, de sorte que vous (en général) ne veulent pas prolonger votre tampon un élément à la fois, comme je l'ai fait ici. Un plus stratégie la plus courante consiste à choisir un point de départ initial de taille qui couvre la plupart des cas, et si vous avez besoin d'étendre la mémoire tampon, le double de sa taille.

    Vous pourriez résumé de l'opération de redimensionnement dans une autre fonction, comme suit:

    int addItem(char ***arr, char *newElement, size_t *count, size_t *bufSize)
{
  if (*count == *bufSize)
  {
     //we've run out of room; extend the buffer
     char **tmp = realloc(**arr, 2 * *bufSize * sizeof **arr);
     if (tmp)
     {
       *arr = tmp;
       *bufSize *= 2;
     }
     else
     {
       //could not extend the buffer; return failure code
       return 0;
     }
  }
  (*arr)[(*count)++] = newElement;
}

    et l'appeler comme

    #define N ... //initial array size

char **array = malloc(N * sizeof *array);
size_t bufSize = N;
size_t count = 0;
...
if (addItem(&array, "This", &count, &bufSize))
  printf("# elements = %zu, buffer size = %zu\n", count, bufSize);

if (addItem(&array, "That", &count, &bufSize))
  printf("# elements = %zu, buffer size = %zu\n", count, bufSize);

    C'est toutes testées et sur le dessus de ma tête; aucune garantie, expresse ou implicite. Mais il devrait être suffisant pour vous diriger dans la bonne direction.

    OriginalL'auteur John Bode

  4. 0

    Ce n'est pas possible. Vous pouvez allouer un tableau de char*, bien que:

    char **array = calloc(2, sizeof(char *));
array[0] = "This";
array[1] = "That";

    OriginalL'auteur Olaf Dietsche