Need a union to make 5 ints from 20 chars

Question

this is my first post here so I will apologize in advance if I mess anything up.

I am writing a program for my class in C and the assignment wants us to read in a string 20 characters long from a file, then use a union to take the string and make 5 ints out of it.

All of my int values are coming out the same, and I can not figure out what else to do. All the examples I can find only really care about taking in a string then making it into one int or an int and a float.

my union is set up as follows

union hashes
{
    char str[20];
    int one;
    int two;
    int three;
    int four;
    int five;
};

int main (void)
{
    union hashes hashes1;
}

A new attempt at showing more of the program

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

union hashes
{
    char str[20];
    int one;
    int two;
    int three;
    int four;
    int five;
};

int main (int argc, char *argv[])
{
    //declare union
    union hashes hashes1;
    //declare struct from link.h
    struct node* current;
    struct node* new_node;
    //file pointer to open file
    FILE *fpointer;
    fpointer = fopen(argv[1], "r");
    //activate first node
    current = (struct node*) malloc(sizeof(struct node));

//read from file
    while (fread(current, 20, 1, fpointer))
    {
        //copy the string to the union
        strncpy(hashes1.str, current->name, 20);
        //add the variables
        printf("string: %s\nInts: %d %d %d %d %d\n", hashes1.str, hashes1.one, hashes1.two, hashes1.three, hashes1.four, hashes1.five);

        new_node = (struct node*) malloc(sizeof(struct node));
        current = new_node;
    }
}

Answer 1

If sizeof(int) is 4 on your platform, use:

union hashes
{
    char str[20];
    int numbers[5];
};

You can also use a fixed width integer.

union hashes
{
    char str[20];
    int32_t numbers[5];
};

Answer 2

All of your ints are the same. Another approach will be having another vector, but this time, of ints. Since the sizeof(int) between platforms can change, you can get the vector size relative to the int size:

union hashes
{
   char str[20];
   int numbers[20 / sizeof(int)];
};

A little test case can be used to prove that both fields have a same size:

int main(void)
{
   union hashes hashes1;

   printf("%lu %lu %lu", sizeof(hashes1), sizeof(hashes1.str),
                         sizeof(hashes1.numbers));
   return 0;
}

That prints 20 20 20. A little Coliru demo.

To know or work with the resulting amount of ints you could do something like:

int main(void)
{
    union hashes hashes1;
    int i;

    if (sizeof(hashes1.numbers) / sizeof(int) != 5)
       printf("In this architecture we cannot extract 5 numbers "
              " from 20 characters\n");
    else {
       printf("The numbers are: ");

       for (i = 0; i < 5; ++i)
         printf("%d ", hashes1.numbers[i]);

       printf("\n");
    }

    return 0;
}

Although usually sizeof(int) == 4, so, you will nearly always get 5 integers, and the first if will be never executed in your tests.

Answer 3

With recent C (e.g. C99 or C11 at least), a union can contain an anonymous struct. So you might code:

union hashes {
  char str[20];
  struct {
    int one;
    int two;
    int three;
    int four;
    int five;
  };
};

and later use hashes1.str and hashes1.three etc.

Be aware that you have no guarantee that an int takes four bytes (or that it is aligned to 4 bytes). You might use <stdint.h> and types like int32_t (a 32 bits signed integer) or uint8_t (an 8 bit unsigned integer, e.g. a byte). See also this and read the standard reference, e.g. n1570 (a draft which is practically the same as the ISO C11 standard).

You should use the sizeof operator (and perhaps also alignof, if alignment is relevant). In particular your call to fread should have sizeof(struct node) or sizeof(union hashes) instead of 20.

^{(BTW, your code is wrong, so won't compile, because struct node is not declared)}

Don't forget to favor readability and portability when writing C code. Be sure to enable all warnings & debug info when compiling (e.g. use gcc -Wall -Wextra -g if using GCC...), then use the debugger (e.g. gdb).