Thread: what does a structure variable mean?

First of all, the program you posted can't give the stated output. Next time cut-and-paste your program to the message.

your program has

Code:

     mystruct.ch[0] = 'A';     // Ascii value 0x41 
     mystruct.ch[1] = 'B';     // Ascii value 0x42
     mystruct.ch[2] = 'C';     // Ascii value 0x43
     mystruct.ch[3] = 'D';     // Ascii value 0x44

should be (I'm guessing)

Code:

     mystruct.ch[0] = 'A';     // Ascii value 0x41 
     mystruct.ch[1] = 'B';     // Ascii value 0x42
     mystruct.ch[2] = 'C';     // Ascii value 0x43
     mystruct.ch[3] = 'D';     // Ascii value 0x44

Now, as to what's happening:


When a struct is used as an argument to a function, the entire struct is pushed on to the stack.

If you want to see how the elements are stored, put the following in your program:

Code:

  char *chpoint;
  int *intpoint;
  int num_ints;
  int i;

   ...
 
     chpoint = (char *)&mystruct;     
     intpoint = (int *)&mystruct;

     num_ints = sizeof(mystruct)/sizeof(int);

     printf("sizeof(mystruct) = %d\n", sizeof(mystruct));

     for (i = 0; i < sizeof(mystruct); i++) {
       printf("0x%08x  0x%02x\n", &chpoint[i], chpoint[i]);
     }
     printf("\n");

     for (i = 0; i < num_ints; i++) {
       printf ("0x%08x  0x%08x\n", &intpoint[i], intpoint[i]);
     }
     printf("\n");

Now in this case, the elements of struct are packed into two ints

The first int contains the bytes 0x41, 0x42, 0x43, and 0x44 (in that order).
The second int contains the value of mystruct.i (decimal 97, the value of the ascii char 'a'.

Now, when mystruct is pushed on the stack, apparently the two ints are pushed in reverse order so that the top of the stack in printf is the int containing the four chars.

Your printf for type1 tells the printf to get an int off of the stack and print its value in hex, so you get 0x44434241 (it thinks it is an int, and this is how ints are stored in little-endian fashion).

Your printf for type 2 tells printf to print a char. Now, chars are always passed as int, so printf gets an int off of stack: (the first four butes of the struct), and print the char value (the least significant byte of the int is 0x41).

Ttttttthat's all folks (unless you want to try some things and tell us something different).

Dave

Originally Posted by no-one

pretty good explaination... Mr.Evans less garbled then what i probably would have done, but more generally what it comes down to is memory is memory its all in how you treat it.

Another thing it boils down to is that printf() doesn't actually know what you pushed on the stack. It gets things off of the stack according to the format specifiers: %d gets an int, %x gets an int, %c pops an int and uses the least significant 8-bits of the integer. There is not a format specifier for a struct (obviously); that's why you would print the elements of the struct according to the struct definition.

Of course there is no guarantee that an int is 32 bits; it just happens to be for lots of compilers that users of this board typically encounter. Any tricks that depend on size of int or endianness of storage are Bad Things.

On the other hand, I think it is a Good Thing to try to understand what's happing "behind the curtain", like seeing how bytes are stored, how arguments are pushed, etc.

Best regards,

Dave

Originally Posted by Salem

Well you could just turn on some warnings and then fix the code

Code:

$ gcc -W -Wall hello.c
hello.c: In function `main':
hello.c:17: warning: unsigned int format, st arg (arg 2)
hello.c:18: warning: int format, st arg (arg 2)

An excellent point: the compiler (or some other tool, like lint) can sometimes point out your oopses, but printf() still doesn't know or care what you used as arguments. It gets its information from your format specification. The original post asked how he could be getting the output that he saw.

Dave

Originally Posted by itsme86

I don't see any difference between these two...

That's funny: I don't either.

Oh, well...


Dave