Thread: Function writes to array for no reason

Code:

int calcSum(struct card playerHand[], int noOfCards) {
    int sum = 0;
    int numberOfAces = 0;
    struct card *ptr;


    for (int j = 0; j < noOfCards; j++)
    {
        ptr = &playerHand[j];
        if (ptr->value = 1)
        {
            numberOfAces++;
        }
    }
    if (numberOfAces != 0) {
        int aceBigSum = 10, aceSmallSum = 0;
        
        for (int i = 0; i < noOfCards; i++)
        {
            ptr = &playerHand[i];
            aceSmallSum += ptr->value;
        }
        for (int i = 0; i < noOfCards; i++)
        {
            ptr = &playerHand[i];
            aceBigSum += ptr->value;
        }
        if ((aceBigSum < aceSmallSum) || (aceBigSum > 21)) 
        {
            return aceSmallSum;
        }
        else 
        {
            return aceBigSum; 
        }
    }
    
    else {
        struct card *ptr2;
        for (int i = 0; i < noOfCards; i++)
        {
            ptr2 = &playerHand[i];
            sum += ptr->value;
        }
        return sum;
    }
}

So, I have this function which gets passed a struct array (of size 9, if that matters) and an int showing how many elements have been assigned values.

For some reason it seems to write 1 to playerHand[0].value and playerHand[1].value, which I don't want it to do. I want the array to keep the same values it had when the call happened.

The struct looks like this:

Code:

struct card {
    int suit;
    int value;
};

The call looks like this:

Code:

calcSum(player1hand,2)

If i write the function like this everything seems to work fine, but it doesn't do what I want the function to do of course:

Code:

int calcSum(struct card playerHand[], int noOfCards) {
    int sum = 0;
    struct card *ptr;
    for (int i = 0; i < noOfCards; i++)
    {
    ptr = &deckAr[i];
    sum += ptr->value;
    }
    return sum;
}

So any ideas? I cant find any clue as to why it would write anything to the array.

/ Finoli

Code:

if (ptr->value = 1)

You want == (comparison), not = (assignment).

1. Provide us with enough code to compile and run your program, and sample input that demonstrates the problem along with what you expect the output to be and the actual output you get. This saves us a ton of time and effort; it helps us help you.

2. Compile at the maximum warning level (e.g. -Wall option for gcc):

Code:

$ make cards
gcc -Wall -ggdb3 -pedantic -std=gnu99 -O0 -o cards cards.c -lm -lpthread -lrt
cards.c: In function ‘calcSum’:
cards.c:17:9: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
         if (ptr->value = 1)
         ^
cards.c:46:22: warning: variable ‘ptr2’ set but not used [-Wunused-but-set-variable]
         struct card *ptr2;
                      ^

That first warning is the cause of overwriting value. A single = is used for assignment, a double == is used for comparison.
That second warning suggests you are doing something wrong in that else block. You declared ptr2, and you point it to elements of the array, but you never use ptr2. You never access the data it points to. Perhaps you meant sum += ptr2->value?

Still, there's no reason to use pointers here, it just confuses things. You can simply do something like sum += playerHand[i];

Given the "21" on line 28, I'm guessing this is a blackjack program. If that's the case, I think you're not correctly handling the case where the player has more than one ace. What should aceBigSum be if there are two aces? What about three?

Why are you still using a size of 9 when I told you in another thread that the maximum possible number of cards in a blackjack hand is 11?

Anyway, your code is overcomplicated.

Code:

int sum = 0, acefound = 0;
for (int i = 0; i < ncards; i++) {
    sum += hand[i].value;
    if (hand[i].value == 1)
        acefound = 1;
}
return (acefound && sum + 10 <= 21) ? sum + 10 : sum;

@anduril, only one ace will ever have the value 11 since two 11's is 22.

Originally Posted by algorism

@anduril, only one ace will ever have the value 11 since two 11's is 22.

But I like to live dangerously.