Dynamique de la mémoire/realloc tableau de chaînes

Cherche à créer un tableau dynamique de la chaîne de valeurs.

Dans l'exemple de code ci-dessous, l'intention était d'une nouvelle matrice de l'élément à ajouter (realloc) et une nouvelle chaîne de caractères ("string " 3") pour être ajouté dans le tableau au moment de l'exécution.

J'imagine que le problème est soit de la mauvaise utilisation des pointeurs et/ou quelque chose de mal avec l'realloc logique?

Reconnaissant de toute aide.

La sortie réelle je suis arriver:

Before: 
Array[0]: string 1
Array[1]: string 2
After: 
Array[0]: string 1
Array[1]: string 2

Le code:

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

char **myArray;

main(int argc, char *argv[])
{
    int i = 0;
    myArray = malloc(2 * sizeof(char*));
    int arrayIndexs = sizeof(*myArray) / sizeof(char*);

    //Allocate memory for each [x]
    for (i = 0; i <= arrayIndexs; i++)
        myArray[i] = malloc(254 * sizeof(char*));
    //Populate initial values
    if(myArray != NULL)
    {
        strcpy(myArray[0], "string 1");
        strcpy(myArray[1], "string 2");
    }
    //Print out array values
    printf("Before: \n");
    for (i = 0; i <= arrayIndexs; i++)
        printf("Array[%d]: %s\n",i, myArray[i]);

    //Expand array to allow one additional item in the array
    myArray = (char **)realloc(myArray, sizeof(myArray)*sizeof(char*));

    //Allocate memory for the new string item in the array
    myArray[arrayIndexs+1] = malloc(254 * sizeof(char*));

    //Populate a new value in the array
    strcpy(myArray[arrayIndexs+1], "string 3"); //

    arrayIndexs = sizeof(*myArray)/sizeof(char*);

    //Print out array values
    printf("After: \n");
    for (i = 0; i <= arrayIndexs; i++)
        printf("Array[%d]: %s\n",i, myArray[i]);
}
Si vous jamais trouvez en essayant d'utiliser sizeof() pour tout, qui est de taille moyenne dynamiquement, vous le faites mal. Gardez cela à l'esprit.

OriginalL'auteur MrDB | 2014-02-22

  1. 3

    Si vous jamais trouvez en essayant d'utiliser sizeof() pour rien qui est de la taille d' dynamiquement, vous le faites mal. Gardez cela à l'esprit. sizeof() est utilisé à plusieurs reprises dans ce code de manière incorrecte. Dynamique de la taille du compte doit être géré par vous; l'allocation des exigences de taille en octets peuvent être gérés à l'aide de ces comptes en conjonction avec un sizeof() du type fondamental pour l'élément stocké.

    Étant donné que:

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

int main(int argc, char *argv[])
{
    int i = 0;
    int arrayIndexes = 2;
    char ** myArray = malloc(arrayIndexes * sizeof(*myArray));

    //Allocate memory for each [x]
    for (i = 0; i < arrayIndexes; i++)
    {
        myArray[i] = malloc(254 * sizeof(char));
        sprintf(myArray[i], "string %d", i+1);
    }

    //Print out array values
    printf("Before: \n");
    for (i = 0; i < arrayIndexes; i++)
        printf("Array[%d]: %s\n", i, myArray[i]);

    //TODO: Fix this to check the result before orphaning the old
    // value of myArray if an allocation failure ensues.
    myArray = realloc(myArray, (arrayIndexes+1) * sizeof(*myArray));
    ++arrayIndexes;

    //Allocate memory for the new string item in the array
    myArray[arrayIndexes-1] = malloc(254 * sizeof(char*));

    //Populate a new value in the array
    strcpy(myArray[arrayIndexes-1], "string 3"); //

    //Print out array values
    printf("After: \n");
    for (i = 0; i < arrayIndexes; i++)
        printf("Array[%d]: %s\n",i, myArray[i]);

    //TODO: write proper cleanup code just for good habits.
    return 0;
}

    Sortie

    Before: 
Array[0]: string 1
Array[1]: string 2
After: 
Array[0]: string 1
Array[1]: string 2
Array[2]: string 3

    OriginalL'auteur WhozCraig

  2. 2

    Vous remplacez cette ligne:

    arrayIndexs = sizeof(*myArray)/sizeof(char*);

    par quelque chose comme ceci:

    arrayIndexs += 1;

    Raison: sizeof est au moment de la compilation de l'opérateur pour déterminer la taille d'un type de données ou le type de données d'un objet, tandis que là, vous ne devez gérer manuellement la taille de la matrice.

    EDTIED: Également lors de l'initialisation de la variable, vous devez utiliser 

    int arrayIndexs = 2;

    au lieu de

    int arrayIndexs = sizeof(*myArray) / sizeof(char*);
    Merci pour le bon & réponse rapide - très apprécié, marqué WhozCraig comme la meilleure réponse en raison de la pleine retravaillé exemple de code.

    OriginalL'auteur starrify