Defining a variable vs. initializing - c

Question

So, I am led to believe by my professor that when declaring the size of an array, it is best to use #define vs. just declaring it as a normal integer. Is this correct?
If so, why?
Also, if this is correct, what am I doing wrong? When I try to do this I get an message:
error: expected ';', ',' or ')' before numeric constant
every time I call the array. The code works if I just initialize it as an integer.
The definition and usage can be seen in the following code:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define handsize 5
#define size 52
// Create function prototypes
void create_deck (int deck[]);
void shuffle_deck (int size, int deck[]);
void display_card (int card);
void display_hand (int size, int hand[]);
int popCard (int *size, int deck[]);
int findScore (int size, int hand[]);
int main()
{
// declare/ initialize variables
int c, d, p, win = 0, lose = 0 , tie = 0, /*handsize = 0, size = 52,*/ deck[size], hand[handsize], dealer[handsize];
char play;
srand(time(NULL)); // attach random number generator to time function for truly random variables
// explain program to user and ask if they want to play
printf("This program is a card game that adds the values of all the\n");
printf("cards in the players hand, and the computers hand. The highest hand wins.\n");
printf("Would you like to play? Please press 'y' for yes, any other key for no.\n");
scanf("%c", &play); // if the user wants to play, continue the program
// while loop that continues as long as the user wants to play
while (play == 'y'){
// call functions to create and shuffle the deck
create_deck(deck);
shuffle_deck (size, deck);
// for loop that calls the popCard function to deal the top card in the deck
for (c = 0; c < 5; c++){
hand[c] = popCard (&size, deck); // player gets a card
dealer[c] = popCard (&size, deck); // computer gets a card
handsize++;
// call the display_hand function to display the individual cards in the players hand
printf("\nYour hand consists of:\n");
display_hand (handsize, hand);
// call the display_hand function to display the individual cards in the dealers hand
printf("Dealer hand consists of:\n");
display_hand (handsize, dealer);
}
// call the findScore function for both the user and the computer
p = findScore (handsize, hand);
d = findScore (handsize, dealer);
// show the value of the user and computers hands
printf("\nThe value of your hand is %i\n", p);
printf("\nThe value of the dealers hand is %i\n", d);
// if statements that keep track of wins, losses and ties
if (p > d)
win++;
if (p == d)
tie++;
if (p < d)
lose++;
// show number of times player has won, lost, tied. Then ask to play again
printf("You have won %i times, tied %i times, and lost %i times\n", win, tie, lose);
printf("\nWould you like to play again?\n");
fflush(stdin); // flush the input buffer to stop false readings
scanf("%c", &play); // read the user input to determine if they want to play again
}
printf("Goodbye");
return 0;
**I hope this is what you wanted

Answer 1

Symbolic constants (either #define or actual constants) are generally preferred.
What happens, for example, when your code is peppered with the value 1440 but you use that number for both twips per inch and kilobytes per floppy (very much showing my age here)?
Then all of a sudden your floppies become 2.88M. You then have to go through all your code looking for 1440 and figuring out if it meant the twips or kilobytes version, and changing the relevant ones. So not only do you have to make the change in multiple places (bad enough), you may also have to figure out whether the change you be made at each place.
Had you instead done:
#define TWIPS_PER_INCH 1440
#define KB_PER_FLOPPY 1440
and then peppered your code with the symbolic names, you could have then just changed one line, without too much thinking or analysis required.
There's a school of thought that any number other than zero or one (and possibly negative one) should have a symbolic constant of some sort. Just make sure you don't make the mistake of doing:
#define FOURTEEN_HUNDRED_AND_FORTY 1440
like one of my minions once tried. I had endless fun trying to explain why that was a bad idea :-)
As to your error, it's certainly possible to declare an array with a preprocessor constant as shown below:
#include <stdio.h>
#include <string.h>
#define VAR 42
int main (void) {
char xyzzy[VAR];
strcpy (xyzzy, "pax is awesome");
puts (xyzzy);
return 0;
}
However, consider the following lines in your code:
#define size 52
void shuffle_deck (int size, int deck[]);
void display_hand (int size, int hand[]);
int popCard (int *size, int deck[]);
int findScore (int size, int hand[]);
hand[c] = popCard (&size, deck);
// and possibly many others.
Because preprocessing is a textual substitution done early in the compilation process, those lines following the first are going to become:
void shuffle_deck (int 52, int deck[]);
void display_hand (int 52, int hand[]);
int popCard (int *52, int deck[]);
int findScore (int 52, int hand[]);
hand[c] = popCard (&52, deck);
and they will cause all sorts of problems, among them that 52 is not a valid variable name in a function prototype, and that you cannot take the address of an integer literal in C because it has no address.
In order to fix this, you define the initial size as a constant:
#define INIT_SZ 52
and use that to set the initial value of a variable size which you can later change, something like:
void doSomethingThatChangesSize (int *pSize) {
(*pSize) += 42;
}
int size = INIT_SZ; // this is the only way you use INIT_SZ
:
doSomethingThatChanges (&size);