Inverted struct order when assigning values to nested structs

Question

I'm compiling C code with nested structs for a 3D engine, and curiously the values I'm assigning to the structures are being inverted when the program is run.

Example code:

#include <stdio.h>

struct vertexes                     // Creates a structure vertexes with 3 coordinates in space
{
    unsigned short x, y, z;         // 2 bytes variables, restricted to 0-65535
};

struct triangles                    // Creates a structure triangles
{
    struct vertexes vertex[3];      // A triangle is made of 3 vertexes, so we create p arrays of three vertexes
};


main()
{
    struct vertexes vertexTest = {1, 2, 3};
    printf("x = %d, y = %d, z = %d \n\n", vertexTest.x, vertexTest.y, vertexTest.z);

    struct triangles triangleTest = {{{1, 2, 3}, {0, 100, 0}, {100, 100, 0}}};

    for (int loop = 0; loop < 3; ++loop)
    {
        printf ("Loop %d \n", loop);
        printf("Vertex coords = %d, %d, %d \n\n", triangleTest.vertex[loop]);
    }
}

The output I get:

x = 1, y = 2, x = 3 (which is fine)

Loop 0
Vertex coords = 3, 2, 1 (here lies the problem: I've assigned 1, 2, 3!)

Loop 1
Vertex coords = 0, 100, 0 (well, you can't really invert this)

Loop 2
Vertex coords = 0, 100, 100 (again, inverted: I've assigned 100, 100, 0)

What am I doing wrong?

Answer 1

The problem lies here:

        printf("Vertex coords = %d, %d, %d \n\n", triangleTest.vertex[loop]);

This does two things:

• puts a structure of type struct vertexes on the stack
• tells printf to pop 3 integers off the stack

This code is essentially assuming your platform puts varargs on the stack in the same order and alignment as your original structure. On a lot of platforms, the first argument is pushed last.

The behavior will be platform dependent. On my system, (Ubuntu Linux) I get the following result:

x = 1, y = 2, z = 3 

Loop 0 
Vertex coords = 131073, 131073, 131072 

Loop 1 
Vertex coords = 6553600, 6553600, 6553600 

Loop 2 
Vertex coords = 6553700, 6553700, 6553600 

i.e. just a bunch of garbage.

How do you fix this? You need to make the format string for printf, and the thing you're providing to printf match.

        printf("Vertex coords = %d, %d, %d \n\n",
            triangleTest.vertex[loop].x,
            triangleTest.vertex[loop].y,
            triangleTest.vertex[loop].z
        );

Speaking of making sure these match, do you have compiler warnings turned on? Any compiler should be able to flag when the number of arguments to printf, and the number of format specifiers don't match. When I turn on the warnings on gcc, it shows the following:

test320.c: In function ‘main’:
test320.c:24:34: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘struct vertexes’ [-Wformat=]
   24 |         printf("Vertex coords = %d, %d, %d \n\n", triangleTest.vertex[loop]);
      |                                 ~^                ~~~~~~~~~~~~~~~~~~~~~~~~~
      |                                  |                                   |
      |                                  int                                 struct vertexes
test320.c:24:38: warning: format ‘%d’ expects a matching ‘int’ argument [-Wformat=]
   24 |         printf("Vertex coords = %d, %d, %d \n\n", triangleTest.vertex[loop]);
      |                                     ~^
      |                                      |
      |                                      int
test320.c:24:42: warning: format ‘%d’ expects a matching ‘int’ argument [-Wformat=]
   24 |         printf("Vertex coords = %d, %d, %d \n\n", triangleTest.vertex[loop]);
      |                                         ~^
      |                                          |
      |                                          int

Your compiler probably has something similar.

You should really turn on warnings. They save a lot of time. I used to think, when I was learning C, that warnings didn't really matter. That changed when I spent three days debugging a program that I could've caught in three minutes had I enabled warnings.

Answer 2

You have to explicitly print each vertex's coordinates like so:

printf("Vertex coords = %d, %d, %d \n\n",
            triangleTest.vertex[loop].x,
            triangleTest.vertex[loop].y,
            triangleTest.vertex[loop].z);

Answer 3

For every %d printf format specifier that you use, you must pass exactly one corresponding int argument.

In the line

printf("Vertex coords = %d, %d, %d \n\n", triangleTest.vertex[loop]);

you are violating this rule, because you are using three %d specifiers, but only one argument, which is also of the wrong type. It is of type struct vertexes, not of type int.

Due to you violating this rule, your program has undefined behavior, which means that anything can happen, including the behavior you describe in the question.

See one of the other answers for a possible explanation of why the order of the values are inverted, when you test your program. However, you cannot rely on the values being inverted, because, as mentioned above, anything may happen when invoking undefined behavior.

If you want the behavior of your program to be reliably predictable, then you should not invoke undefined behavior, by following the rule mentioned above, for example like this:

printf(
    "Vertex coords = %d, %d, %d \n\n",
    triangleTest.vertex[loop].x
    triangleTest.vertex[loop].y
    triangleTest.vertex[loop].z
);

Although these arguments are of type unsigned short instead of int, this is acceptable, because when passing an unsigned short to printf, it will get implicitly promoted to int.

However, I would recommend using %hu instead of %d for the unsigned short data type, because that way, you can use the same format specifier for both the printf and scanf family of functions and you don't have to take int promotions into account.

See the documentation for printf and scanf for further information on the format specifiers.