Thread: creating a function with class objects

Arguments are passed by value to functions, so changes to them are local to the function (not visible to the caller).

If you want changes to an argument to be visible to the caller, either pass a reference or a pointer. Then, inside the function, change whatever the pointer points at, or whatever the reference references.


I fail to see the point of using a float for counting.

In terms of the algorithm, try using a loop.

I figured out I was using the wrong type for the function prototype, so now I have this...

Code:

void checkFlush (Card::Suit arr[5], int f) {
    if (arr[0] == arr[1] &&    
        arr[0] == arr[2] &&
        arr[0] == arr[3] &&
        arr[0] == arr[4])
        f++;
}

I was using a float for counting because later in the program I need to divide by that variable, and dividing by integers is usually inconsistent, isn't it?
This code works now, but when I use it in main() I have this:

Code:

checkFlush (handSuit, flush);

and flush always ends up not incrementing like it should be. I tried testing to see whether it was incrementing in the function by outputting "f" and that worked, so I'm guessing my problem is outside the function?

EDIT: Just something else to note, if I use this code in main() (not as a function) and replace "f" with "flush" it works fine...

You have a fundamental misunderstanding of how arguments are passed to functions. Only the VALUE of flush is passed to checkFlush, i.e., f gets a COPY of flush's value. Changing f in checkFlush therefore won't change flush in main.

To let a function change the value of a variable in the caller, you can pass it "by reference" by changing the function declaration like this:

Code:

void checkFlush (Card::Suit arr[5], int &f)

The call in main stays the same.

Originally Posted by ryanmcclure4

I was using a float for counting because later in the program I need to divide by that variable, and dividing by integers is usually inconsistent, isn't it?

Dividing by integers is not "inconsistent". It is performed as an integer operation, so the result is an integer, which means rounding. [There are particular cases, with older standards and older compilers, where the result of integer division is undefined, but that is also not "inconsistent").

So if an integer x has value 2 and integer y has value 3, the operation z=x/y will consistently give the result zero, not 0.66667, even if z is of type float. If you really care about the fractional result, then force the compiler to convert to floating point before doing the division. z = (float)x/y will not perform the rounding.

But that behaviour is not inconsistency.

Even if such behaviour is considered a bad thing, using float/double types is not always a good fix, because float/double types are an approximation of real values, not actual real values. Try to represent the fraction 1/5 in a finite number of binary places to see why .... you will find that it cannot be done, in exactly the same way that the fraction 2/3 cannot be represented using a finite number of decimal places (0.66666.... <ad infinitum>)

OK, you really have to think about this.

You have a VOID function that returns a value as a parameter. This is nonsense. The idea of this function is to return a value, so return it:

Code:

int checkFlush (Card::Suit arr[5]) 
{
    int f = 0;
    if (arr[0] == arr[1] &&   
        arr[0] == arr[2] &&
        arr[0] == arr[3] &&
        arr[0] == arr[4])
            f = 1;
    return f;
}

This essentially returns 0 or FALSE if the hand is not a flush.
It returns 1 or TRUE if the hand is a flush.

When you get to checkPair(), the return value can be the number of pairs found. Keep in mind that three of a kind should not be considered in the pair testing, otherwise you get 3 pairs...