L'appel de memset provoque des erreur de segmentation

Ce programme provoque une seg fault sur ma machine UNIX. J'ai réduit la cause jusqu'à la deuxième appel de memset().

Pourquoi ce comportement est-il survenu? Le premier "morceau" de code est presque le même que le second, n'est-ce pas? Pourquoi ne pas l' première appel de memset erreur de segmentation si le second n'?

J'ai regardé sur d'autres threads concernant segfaulting memset des appels, mais aucun d'entre eux étaient similaires à ce.

Dans le cas où vous vous demandez pourquoi j'ai écrit un tel trivial programme, il est adapté à partir d'un autre programme que j'ai écrit que j'utilisais pour m'enseigner comment appliquer memcpy() pour les structures.

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

typedef struct{
    int x;
    char text;
} FilesStruct;

int
main(int argc, char** argv)
{
    FilesStruct *old_dir;
    memset(old_dir,0,sizeof(FilesStruct));
    old_dir->x = 3;
    old_dir->text = 'c';
    printf("old dir: %d,%c\n",old_dir->x,old_dir->text);

    FilesStruct *new_dir;
    memset(new_dir,0,sizeof(FilesStruct));
    new_dir->x = 7;
    new_dir->text = 'g';
    printf("new dir: %d,%c\n",new_dir->x,new_dir->text);

    return 0;
}

OriginalL'auteur python_newbie | 2013-05-28

  1. 10
    FilesStruct *old_dir;
memset(old_dir,0,sizeof(FilesStruct));

    tente d'écrire à un pointeur non initialisée. Il en résulte un comportement indéterminé, y compris, éventuellement, d'un crash. Son juste de la chance (bon ou mauvais, selon la façon dont vous le regardez) que la première instance de ce comportement ne tombe pas en panne.

    Vous avez besoin d'allouer de la mémoire pour old_dir. La façon la plus simple de le faire est de les déclarer sur la pile

    FilesStruct old_dir;
memset(&old_dir,0,sizeof(old_dir));

    ou vous pouvez allouer dynamiquement sur le tas (assurez-vous d'appeler free lorsque vous n'avez plus besoin de l'objet)

    FilesStruct *old_dir = calloc(1, sizeof(*old_dir);
/* use old_dir */
free(old_dir);

    La même chose s'applique à new_dir plus bas dans votre code.

    Oh, j'avais l'intention d'utiliser memset comme un initialiser, suppose que je suis assez mauvais. Donc ma déclaration que déclare un pointeur, mais pas la structure sous-jacente; par conséquent, j'ai besoin d'allouer de la mémoire avant de memsetting à 0?
    Oui, c'est ça exactement
    Merci pour votre aide!

    OriginalL'auteur simonc

  2. 3

    Ni old_dir ni new_dir sont initialisés, donc c'est un comportement indéfini. Une solution serait d'allouer à la fois des variables sur la pile:

    FilesStruct old_dir;
//...
FilesStruct new_dir;

    et l'utilisation de la & opérateur pour obtenir l'adresse lors de l'appel de memset:

    memset(&old_dir,0,sizeof(FilesStruct));

    OriginalL'auteur Shafik Yaghmour

  3. 3
    FilesStruct *old_dir;

    Ceci définit une FilesStruct pointeur. Il est non initialisée, donc il n'a pas vraiment de point de stockage pour un FilesStruct.

    memset(old_dir,0,sizeof(FilesStruct));

    Dira memset à zéro à n'importe quelle old_dir points, mais que le pointeur est initialisé, vous obtenez un comportement indéfini.

    Vous aurez besoin de fournir un stockage pour votre pointeur, par exemple

    FilesStruct *old_dir = malloc(sizeof(FilesStruct));

    Dans votre cas, vous n'avez pas vraiment besoin d'un pointeur ou de la mémoire allouée dynamiquement, vous pourriez faire 

    FilesStruct old_dir;
memset(&old_dir,0,sizeof(FilesStruct));
old_dir.x = 3;
old_dir.text = 'c';
printf("old dir: %d,%c\n",old_dir.x,old_dir.text);

    OriginalL'auteur nos