Erreur de fin à la fin du programme après avoir exécuté tout?

Question

J'ai écrit un programme rapide qui exécute chaque instruction avant de donner une erreur de faute de seg.

struct foo 
{ 
    int cat; 
    int * dog; 
}; 

void bar (void * arg) 
{ 
    printf("o hello bar\n"); 
    struct foo * food = (struct foo *) arg; 
    printf("cat meows %i\n", food->cat); 
    printf("dog barks %i\n", *(food->dog)); 
} 
void main() 
{ 
    int cat = 4; 
    int * dog; 
    dog = &cat; 

    printf("cat meows %i\n", cat); 
    printf("dog barks %i\n", *dog); 

    struct foo * food; 
    food->cat = cat; 
    food->dog = dog; 

    printf("cat meows %i\n", food->cat); 
    printf("dog barks %i\n", *(food->dog)); 

    printf("time for foo!\n"); 
    bar(food); 
    printf("begone!\n"); 

    cat = 5; 
    printf("cat meows %i\n", cat); 
    printf("dog barks %i\n", *dog); 

// return 0; 
} 

qui donne un résultat de

cat meows 4 
dog barks 4 
cat meows 4 
dog barks 4 
time for foo! 
o hello bar 
cat meows 4 
dog barks 4 
begone! 
cat meows 5 
dog barks 5 
Segmentation fault (core dumped) 

Je ne suis pas vraiment sûr pourquoi il segmente les défauts à la fin? Tous les commentaires/idées sont profondément appréciés.

Answer 1

Vous déréférencer un pointeur vers une mémoire non valide, food.

La ligne:

struct foo * food; 

déclare la nourriture pour être un pointeur vers une struct foo. Mais puisque vous n'initialisez pas le pointeur, cela pointe vers une zone de mémoire indéfinie que vous ne possédez pas. Vous pouvez soit juste allouer sur la pile (notez que j'ai changé le type de nourriture):

struct foo food; 
food.cat = cat; 
food.dog = dog; 

printf("cat meows %i\n", food.cat); 
printf("dog barks %i\n", *(food.dog)); 

printf("time for foo!\n"); 
bar(&food); 

ou utilisez malloc (en gardant le type comme * struct foo):

struct foo * food = malloc(sizeof(struct foo)); 
if(food == NULL) 
    perror("Failed to allocate food."); 

Plus tard, vous devriez libérer (bien que dans ce cas, il importe peu):

free(food); 

il y a d'autres problèmes avec le programme (par exemple le paramètre void *), mais cela répond à la violation de la mémoire.

Answer 2

Eh bien, ces lignes sont un problème:

struct foo * food; 
food->cat = cat; 
food->dog = dog; 

La nourriture est un pointeur que vous déréférencer sans qu'il soit affecté à quoi que ce soit.

struct foo food; 
food.cat = cat; 
food.dog = dog; 

peut résoudre des problèmes pour vous.

Answer 3

Vous obtenez un comportement indéfini parce que vous n'avez pas malloc la structure alimentaire.

Answer 4

Vous n'avez pas alloué un espace pour une variable de structure à pointée par la variable food:

struct foo * food; 

que vous devez faire:

struct foo * food = (struct foo*) malloc(sizeof(struct foo)); 

aussi vous devriez Désallocation cette mémoire une fois que vous êtes fait en l'utilisant:

free(food); 

Alternative vous pouvez déclarer la nourriture comme une variable de type struct foo comme:

struct foo food; // note the missing * 

et vous pouvez accéder aux membres de la structure à l'aide de l'opérateur INPLACE . de l'opérateur ->.si cela ne vous dérange pas

food->cat = cat; 

Changements à

food.cat = cat;