Problem using '--' on a variable via a pointer

Question

Hello.
I'm new to C (been learning just over a week now), so if you take the time to reply - please don't pitch the answer too high!
I've just finished work on my latest project - a Sudoku Solver. It only does simple puzzles, but it (finally) works.
Here's a basic run-down of what it does: a user enters the known numbers of a Sudoku grid, line by line, and the program assigns these to an array (if the number is unknown, the relevant part of the array is set to zero). The array also holds a 'possibles' value for each cell, which says how many numbers are still potential values for that cells (so, when the user's input is first translated into the array, this value will be nine for an empty cell).
A series of structs are then set up, one per cell, which hold various bits of information about each cell. The main things are the coordinates for each cell, together with whether each number (one to nine) is a possibility for that cell, and the total number of possibilities for that cell (which is a pointer to the 'possibles' value in the array, mentioned earlier).
The solving loop is split into two parts. The first goes through each struct, and determines whether the value for that cell is known or not. If it is, that value is removed as a possibility for each cell in its row, column, and box.
The second part of the loop goes through all cells and, if only one possibility exists for a cell, assigns that as the final answer in the array. The solving loop then continues until all cells are solved.
My problem came when reducing the 'possibles' value for a cell in the array, via the struct. My first attempt used this line:
*mySudoku[j].possibles--
('mySudoku' is the name of the struct type; 'j' is a value (0-81), and 'possibles' is a field that points to the value in the array that holds how many potential answers there still are for that cell). In my mind, that code snippet should point at the address held in that struct's field, and reduce it by one.
After much banging of head against a wall, I discovered that the above code snippet wasn't doing the same as:
*mySudoku[j].possibles = (*mySudoku[j].possibles)-1
Once I'd changed the code over, the program worked like a dream.
My question is: why aren't those two bits of code doing the same thing? I've obviously misunderstood something fairly basic, but I can't understand what.
If any of my explanation isn't clear, then please let me know and I'll clarify.
Thanks for your time,
Pete.
Message was edited by: Pete_M2

Answer 1

Pete_M2 wrote:
*mySudoku[j].possibles--
*mySudoku[j].possibles = (*mySudoku[j].possibles)-1
My question is: why aren't those two bits of code doing the same thing? I've obviously misunderstood something fairly basic, but I can't understand what.
In a word, precedence. The first operation performed is the array subscript. Then the member selection via ".". Next is postfix decrement. The pointer dereference is done last.
You should probably use parentheses to clearly specify the order in which you want operations to be performed. I am and have always been virtually clueless about precedence. I always use parentheses to clearly indicate what I want to be done. Even if they are redundant, they still help to clarify the situation.
I would have written the above code as:
--(*mySudoku[j].possibles)
I would use prefix decrement because I don't need the pre-decrement value. I use the parentheses for clarity even though they supposedly aren't needed with prefix decrement. I say "supposedly" because I really have no clue. I have been programming for 20 year and the only precedence I know is parenthesis trumps all (usually).