C For Loop Comparison Using Function Doesn't Wait - c

Question

This is kind of strange, imo, I have a for loop that does a comparison
using the return value from a function.
for (size_t i = 0; i < func(val); i++) {
printf("Value from array modified in func = %u", values[i]);
}
The issue is the loop seems to run before the function is finished, if have a printf in the called function some output occurs before the output of the loop, expected, and some after, not expected. The function is only called in the for loop comparison so output should all happen before for loop's output. If I use a var instead such as:
size_t temp = func(val);
for (size_t i = 0; i < temp; i++) {
printf("Value from array modified in func = %u", values[i]);
}
Then everything works correctly, this is rather odd to me, I'm not using threads so this should all be synchronus right? So why would the loop not wait for func(val) to return?
Here's the original code (cutting out a bunch of comments):
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdlib.h>
#define SUITS 4
#define FACES 13
#define CARDS 52
#define HAND 5
typedef struct {
unsigned int suit;
unsigned int face;
} card;
size_t checkX(card hand[HAND], unsigned int faces[HAND], unsigned int num);
int main() {
card hand[HAND] = {{1,1},{1,7},{1,1},{1,4},{1,7}};
const char *suit[SUITS] = {"Hearts", "Diamonds", "Clubs", "Spades"};
const char *face[FACES] = {"Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"};
unsigned int matchingFaces[HAND] = {0};
for (size_t i = 0; i < checkX(hand, matchingFaces, 2); ++i) {
printf("Pair of %s%s\n", face[matchingFaces[i]], matchingFaces[i] == 5 ? "es" : "s");
}
}
size_t checkX(card hand[HAND], unsigned int faces[HAND], unsigned int num) {
size_t facePos = 0;
for (size_t i = 0; i < HAND - 1; i++) {
size_t count = 1;
for (size_t j = i + 1; j < HAND; j++) {
printf("%u == %u && %u != %u\n", hand[i].face, hand[j].face, hand[i].face, faces[facePos]);
if (hand[i].face == hand[j].face && hand[i].face != faces[facePos]) count++;
}
faces[facePos] = hand[i].face;
if (count == num) facePos++;
}
return facePos;
}
Some of this isn't my code, I was given a basic card shuffling type of program and told to modify it to deal a hand and check for pairs/three of a kind. Like I said this does work when I set the return value of checkX as a variable and then compare i to that instead of directly, I just don't know why. I've tried disabling gcc optimization, which didn't seem to make a difference.
Output from direct func comparison:
1 == 7 && 1 != 0
1 == 1 && 1 != 0
1 == 4 && 1 != 0
1 == 7 && 1 != 0
7 == 1 && 7 != 0
7 == 4 && 7 != 0
7 == 7 && 7 != 0
1 == 4 && 1 != 0
1 == 7 && 1 != 0
4 == 7 && 4 != 1
Pair of Deuces
1 == 7 && 1 != 1
1 == 1 && 1 != 1
1 == 4 && 1 != 1
1 == 7 && 1 != 1
7 == 1 && 7 != 1
7 == 4 && 7 != 1
7 == 7 && 7 != 1
1 == 4 && 1 != 7
1 == 7 && 1 != 7
4 == 7 && 4 != 1
Output from indirect comparison of func using variable:
1 == 7 && 1 != 0
1 == 1 && 1 != 0
1 == 4 && 1 != 0
1 == 7 && 1 != 0
7 == 1 && 7 != 0
7 == 4 && 7 != 0
7 == 7 && 7 != 0
1 == 4 && 1 != 0
1 == 7 && 1 != 0
4 == 7 && 4 != 1
Pair of Deuces
Pair of Eights
I know this code isn't the nicest but I had to work with what was given and just need to make it work, so this question is just out of curiosity.

Answer 1

for (size_t i = 0; i < func(val); i++) {
printf("Value from array modified in func = %u", values[i]);
}
func(val) gets called multiple times here, each time a decision needs to be made whether to continue the loop or not, you can picture it as
size_t i = 0;
if (i < func(val)) {
printf(.....);
i++;
if (i < func(val)) {
printf(.....);
i++;
if (i < func(val)) {
printf(.....);
i++;
if (i < func(val)) {
printf(.....);
i++;
....and so on......
}
}
}
}
So you can see, func(val) may get called multiple times.

Answer 2

A rather good, but a little out of date, section of the great book "The C Programming Language", by Kernighan and Ritchie, re-state a for loop to the equivalent:
{
size_t i = 0;
while (i < func(val)){
printf("Value from array modified in func = %u", values[i]);
i++;
}
}
(The outer braces are mine and are necessary since you can now declare a variable inside the first "expression" in the for loop.)
If you write the loop this way, it's plain to see that func(val) is re-evaluated on each iteration. That is what is causing the effects you observe. (Note that not all languages do this, VBA and VB6 are two examples where the end condition of the for loop is not re-evaluated.)
Because of this, if func(val) is an expensive function and your algorithm doesn't require repeated evaluation, you might want to consider pre-computing the value in advance. Some compilers may optimise out the re-evaluation especially if you are using a standard function like strlen for example, but such an optimisation is a very tricky science.