Question

The task of the program is to push all the data from a structure into a stack, using memcpy.
Upon execution, it successfully enters the data into the structure, but reaches a segmentation fault when it comes to the push() function.

Here’s the code:

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

typedef struct STD {
   char ime [50];
   int fn;
   float usp;
   } STD;


 typedef struct STACK {
    STD *s;
    STACK *next;

    } STACK;
  int push (void *a, int siz,  STACK **sst) {
STACK *snew;
snew = (STACK *) malloc (siz + 1);
memcpy (snew->s, a, siz); 
 snew -> next = *sst;
 *sst = snew;


 }

int main () {
STACK *st;
STD  ss;

printf ("Vyvedi ime");
gets (ss.ime);
ss.ime[49] = 0;
printf ("Vyvedi fn");
scanf ("%d", &ss.fn);

printf ("Vyvedi usp");
scanf ("%f", &ss.usp);



push (&ss, sizeof(ss) , &st);



system ("pause");      }

Don’t know if it matters, I use DevC as a compiler.

Answer 1

This code is wrong:

STACK *snew;
snew = (STACK *) malloc (siz + 1);
memcpy (snew->s, a, siz); 

snew->s is not initialized when you memcpy a into it. I would expect to see two mallocs – one for STACK* and another for STD*, which you would then use to seed snew->s before copying stuff into it.

STACK *snew;
snew = (STACK *) malloc (sizeof(STACK));
snew->s = (STD*) malloc(sizeof(STD));
memcpy (snew->s, a, siz);

Alternatively you could use a single malloc, and point snew->s to the appropriate offset within it (after you’ve left space for the STACK struct).

STACK *snew;
snew = (STACK *) malloc (sizeof(STACK) + siz + 1);
snew->s = (char*)snew + sizeof(STACK);
memcpy (snew->s, a, siz);

The siz parameter on your push function seems superfluous, since you are always passing in a struct STD.