Segmentation fault while trying to print parts of a pointer struct

Question

I'm writing a program that must take user input to assign values to parts of a structure. I need to create a pointer to the structure that I will pass through as a one and only parameter for a function that will print each part of the structure individually. I also must malloc memory for the structure. As it is now, the program compiles and runs through main and asks the user for inputs. A segmentation fault occurs after the last user input is collected and when I'm assuming the call to the printContents function is run. Any help would be appreciated!

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

struct info
{
        char name[100], type;
        int size;
        long int stamp;
};

void printContents(struct info *iptr);

int main(void)
{
        struct info *ptr=malloc(sizeof(struct info));

                printf("Enter the type: \n");
                scanf("%c", &(*ptr).type);
                printf("Enter the filename: \n");
                scanf("%s", (*ptr).name);
                printf("Enter the access time: \n");
                scanf("%d", &(*ptr).stamp);
                printf("Enter the size: \n");
                scanf("%d", &(*ptr).size);

        printf("%c", (*ptr).type);

        printContents(ptr);

}

void printContents(struct info *iptr)
{

        printf("Filename %s Size %d Type[%s] Accessed @ %d \n", (*iptr).name, (*iptr).size, (*iptr).type, (*iptr).stamp);

}

Answer 1

Check the operator precedence. Is this &(*ptr).type the thing you're trying to do? Maybe &((*ptr).type) ?

Answer 2

ptr->member is like access to structure variable right? Also same for scanf() usr &ptr->member to get value. For char input use only ptr->charmember .

Answer 3

First let's do it the hard way. We'll assume that the code is already written, the compiler tells us nothing useful, and we don't have a debugger. First we put in some diagnostic output statements, and we discover that the crash happens in printContents:

printf("testing four\n"); /* we see this, so the program gets this far */
printf("Filename %s Size %d Type[%s] Accessed @ %d \n", (*iptr).name, (*iptr).size, (*iptr).type, (*iptr).stamp);
printf("testing five\n"); /* the program crashes before this */

If we still can't see the bug, we narrow the problem down by preparing a minimal compete example. (This is a very valuable skill.) We compile and run the code over and over, commenting things out. When we comment something out and the code still segfaults, we remove it entirely; but if commenting it out makes the problem go away, we put it back in. Eventually we get down to a minimal case:

#include <stdio.h>

int main(void)
{
  char type;

  type = 'a';

  printf("Type[%s]\n", type);
}

Now it should be obvious: when we printf("%s", x) something, printf expects x to be a string. That is, x should be a pointer to (i.e. the address of) the first element of a character array which ends with a null character. Instead we've given it a character (in this case 'a'), which it interprets as a number (in this case 97), and it tries to go to that address in memory and start reading; we're lucky to get nothing worse than a segfault. The fix is easy: decide whether type should be a char or a char[], if it's char then change the printf statement to "%c", if it's char[] then change its declaration.

Now an easy way. If we're using a good compiler like gcc, it will warn us that we're doing something fishy:

gcc foo.c -o foo
foo.c:35: warning: format ‘%s’ expects type ‘char *’, but argument 4 has type ‘int’

In future, there's a way you can save yourself all this trouble. Instead of writing a lot of code, getting a mysterious bug and backtracking, you can write in small increments. If you had added one term to that printf statement at a time, you would have seen exactly when the bug appeared, and which term was to blame.

Remember: start small and simple, add complexity a little at a time, test at every step, and never add to code that doesn't work.