L'attribution de mémoire à double pointeur?

Je vais avoir du mal à comprendre comment attribuer de la mémoire
pour un double pointeur.
Je veux lire un tableau de chaînes et de les stocker.

    char **ptr;
    fp = fopen("file.txt","r");
    ptr = (char**)malloc(sizeof(char*)*50);
    for(int i=0; i<20; i++)
    {
       ptr[i] = (char*)malloc(sizeof(char)*50);
       fgets(ptr[i],50,fp);
    }

au lieu de ce que je viens juste d'attribuer un grand bloc de mémoire et
magasin de la chaîne

  char **ptr;
  ptr = (char**)malloc(sizeof(char)*50*50);

où serait le mal? Et si oui, pourquoi est-il?

Ne pas l'appeler "double pointeur" - cela vous arrive sur le mauvais pied mentalement - c'est un pointeur vers un pointeur.

OriginalL'auteur lazy_hack | 2010-02-13

  1. 12

    Votre deuxième exemple est mauvais car chaque emplacement de mémoire sur le plan conceptuel ne permettrait pas de tenir un char* mais plutôt un char. Si vous légèrement changer votre façon de penser, il peut vous aider avec ceci:

    char *x;  //Memory locations pointed to by x contain 'char'
char **y; //Memory locations pointed to by y contain 'char*'

x = (char*)malloc(sizeof(char) * 100);   //100 'char'
y = (char**)malloc(sizeof(char*) * 100); //100 'char*'

//below is incorrect:
y = (char**)malloc(sizeof(char) * 50 * 50);
//2500 'char' not 50 'char*' pointing to 50 'char'

    À cause de cela, votre première boucle serait de savoir comment vous le faire en C, un tableau de caractères tableaux/pointeurs. L'utilisation d'un bloc de mémoire pour un tableau de tableaux de caractères est ok, mais vous devez utiliser un seul char* plutôt qu'un char**, puisque vous n'aurait pas de pointeurs en mémoire, juste chars.

    char *x = calloc(50 * 50, sizeof(char));

for (ii = 0; ii < 50; ++ii) {
    //Note that each string is just an OFFSET into the memory block
    //You must be sensitive to this when using these 'strings'
    char *str = &x[ii * 50];
}
    ne pas la dernière ligne être char *str = x+(ii*50)?
    Et ne jette pas le résultat de malloc()!

    OriginalL'auteur

  2. 3

    je vais donner un exemple, qui pourrait éclaircir le doute,

    char **str;                              //here its kind a equivalent to char *argv[]
str = (char **)malloc(sizeof(char *)*2)  //here 2 indicates 2 (char*)
str[0]=(char *)malloc(sizeof(char)*10)   //here 10 indicates 10 (char)
str[1]=(char *)malloc(sizeof(char)*10)   //<same as above>

strcpy(str[0],"abcdefghij");   //10 length character 
strcpy(str[1],"xyzlmnopqr");   //10 length character

cout<<str[0]<<endl;    //to print the string in case of c++
cout<<str[1]<<endl;    //to print the string in case of c++

or

printf("%s",str[0]);
printf("%s",str[1]);  

//finally most important thing, dont't forget to free the allocated mem
free(str[0]);
free(str[1]);
free(str);

    OriginalL'auteur

  3. 1

    Un double pointeur est un pointeur vers un autre pointeur. De sorte que vous pouvez répartir comme ceci:

    char *realptr=(char*)malloc(1234);
char **ptr=&realptr;

    Vous devez garder à l'esprit lorsque votre pointeur est stocké (dans cet exemple, le double d'un pointeur sur un pointeur de variable sur la pile de sorte qu'il est invalide après le retour de fonction).

    OriginalL'auteur

  4. 1

    autre moyen plus simple de mémoriser

    Cas -1 :

    étape 1 : char *p;

    étape -2 :
    veuillez le lire comme ci-dessous

    char (*p); ==> p est un pointeur vers un char

    maintenant, vous juste besoin de malloc pour le type (étape 2) sans accolades

    i.e., p = malloc(sizeof(char) * some_len);

    Cas -2 :

    étape 1 : char **p;

    étape -2 :

    veuillez lire comme ci-dessous

    char* (* p); ==> p est un pointeur vers un char *

    maintenant, vous juste besoin de malloc pour le type (étape 2) sans accolades

    i.e., p = malloc(sizeof(char *) * some_len);

    Cas -3 :

    Personne n'utilise de cela, mais juste par souci d'explication

    char ***p;

    lire,

    char** (*p); ==> p est un pointeur vers un char** (et pour cette case cas 2 ci-dessus)

    p = malloc(sizeof(char**) * some_len);

    OriginalL'auteur

  5. 1
     char **ptr;
    fp = fopen("file.txt","r");
    ptr = (char**)malloc(sizeof(char*)*50);
    for(int i=0; i<50; i++)
    {
       ptr[i] = (char*)malloc(sizeof(char)*50);
       fgets(ptr[i],50,fp);
    }

fclose(fp);

    peut être de votre faute de frappe erreur, mais votre boucle doit être de 50 au lieu de 20 si vous êtes à la recherche de 50 x 50 de la matrice. Aussi, après la répartition de la mémoire mentionné ci-dessus, vous pouvez accéder à la mémoire tampon ptr[i][j] - je.e dans le format 2D.

    OriginalL'auteur

  6. 0

    L'ajout de Pent réponse, comme il l'a souligné à juste titre, vous ne serez pas en mesure d'utiliser cette double pointeur une fois que la fonction renvoie la, car il sera le point dans un emplacement de mémoire sur la fonction d'activation de l'enregistrement sur la pile qui est maintenant obsolète (une fois que la fonction a retourné). Si vous souhaitez utiliser cette double pointeur de fois que la fonction a retourné, vous pouvez faire ceci:

    char * realptr = (char *) malloc(1234);
char ** ptr = (char **) malloc(sizeof(char *));
*ptr = realptr;
return ptr;

    Le type de retour de la fonction doit évidemment être char ** pour cela.

    OriginalL'auteur

  7. -4

    Double pointeur est, tout simplement, un pointeur vers un pointeur,
    Dans de nombreux cas, il est utilisé comme un tableau de d'autres types.

    Par exemple, si vous souhaitez créer un tableau de chaînes, vous pouvez tout simplement faire:

    char** stringArray = calloc(10, 40);

    cela va créer un tableau de taille 10, chaque élément sera une chaîne de caractères de longueur 40.

    ainsi, vous pouvez y accéder en stringArray[5] et obtenir une chaîne de caractères en 6ème position.

    c'est un usage, les autres sont comme mentionné ci-dessus, un pointeur vers un pointeur, et peuvent être attribués simplement par:

    char* str = (char*)malloc(40);
char** pointerToPointer = &str //Get the address of the str pointer, valid only in the current closure.

    lire la suite ici:
    bon éventail tutoriel

    Non, cela crée une matrice unique de 100 char*, en supposant char* prend 4 octets.
    Ce que Hans dit est correct. Même plus, le tableau de 100 char* est initialisé à 0 (depuis que vous avez utilisé calloc) donc, tous ceux char* pointent vers nulle et l'accès à celle-tableau de l'emplacement d'origine de l'erreur.

    OriginalL'auteur