Fehler: unbenutzte Parameter 'Kachel'

Question

Ich habe alles versucht und mein Spiel der Fünfzehn ist ein Fehler weg von kompiliert werden. Das einzige Problem ist, dass ich irgendwie den "unbenutzten Parameterfehler" bekomme und mir sage, dass mein Code den Kachelparameter nicht benutzt ... was er sollte! Hier ist der Fehler:

---

fifteeen.c:312:15: error: unused parameter 'tile' [-Werror,-Wunused-parameter] 

void swaptile(tile) 
1 error generated. 

---

Und hier ist der Code

/** 
* fifteen.c 
* 
* Implements Game of Fifteen (generalized to d x d). 
* 
* Usage: fifteen d 
* 
* whereby the board's dimensions are to be d x d, 
* where d must be in [DIM_MIN,DIM_MAX] 
* 
* Note that usleep is obsolete, but it offers more granularity than 
* sleep and is simpler to use than nanosleep; `man usleep` for more. 
*/ 

#define _XOPEN_SOURCE 500 

#include <cs50.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 

// constants 
#define DIM_MIN 3 
#define DIM_MAX 9 

// board 
int board[DIM_MAX][DIM_MAX]; 

// dimensions 
int d; 
int tile_row; 
int tile_column; 
int blank_row; 
int blank_column; 

// prototypes 
void clear(void); 
void greet(void); 
void init(void); 
void draw(void); 
bool move(int tile); 
bool won(void); 

void search(int tile); 
bool legalmove(void); 
void swaptile(int tile); 

int main(int argc, string argv[]) 
{ 
    // ensure proper usage 
    if (argc != 2) 
    { 
     printf("Usage: fifteen d\n"); 
     return 1; 
    } 

    // ensure valid dimensions 
    d = atoi(argv[1]); 
    if (d < DIM_MIN || d > DIM_MAX) 
    { 
     printf("Board must be between %i x %i and %i x %i, inclusive.\n", 
      DIM_MIN, DIM_MIN, DIM_MAX, DIM_MAX); 
     return 2; 
    } 

    // open log 
    FILE* file = fopen("log.txt", "w"); 
    if (file == NULL) 
    { 
     return 3; 
    } 

    // greet user with instructions 
    greet(); 

    // initialize the board 
    init(); 

    // accept moves until game is won 
    while (true) 
    { 
     // clear the screen 
     clear(); 

     // draw the current state of the board 
     draw(); 

     // log the current state of the board (for testing) 
     for (int i = 0; i < d; i++) 
     { 
      for (int j = 0; j < d; j++) 
      { 
       fprintf(file, "%i", board[i][j]); 
       if (j < d - 1) 
       { 
        fprintf(file, "|"); 
       } 
      } 
      fprintf(file, "\n"); 
     } 
     fflush(file); 

     // check for win 
     if (won()) 
     { 
      printf("ftw!\n"); 
      break; 
     } 

     // prompt for move 
     printf("Tile to move: "); 
     int tile = GetInt(); 

     // quit if user inputs 0 (for testing) 
     if (tile == 0) 
     { 
      break; 
     } 

     // log move (for testing) 
     fprintf(file, "%i\n", tile); 
     fflush(file); 

     // move if possible, else report illegality 
     if (!move(tile)) 
     { 
      printf("\nIllegal move.\n"); 
      usleep(500000); 
     } 

     // sleep thread for animation's sake 
     usleep(500000); 
    } 

    // close log 
    fclose(file); 

    // success 
    return 0; 
} 

/** 
* Clears screen using ANSI escape sequences. 
*/ 
void clear(void) 
{ 
    printf("\033[2J"); 
    printf("\033[%d;%dH", 0, 0); 
} 

/** 
* Greets player. 
*/ 
void greet(void) 
{ 
    clear(); 
    printf("WELCOME TO GAME OF FIFTEEN\n"); 
    usleep(2000000); 
} 

/** 
* Initializes the game's board with tiles numbered 1 through d*d - 1 
* (i.e., fills 2D array with values but does not actually print them). 
*/ 
void init(void) 
{ 
    /* total tiles to be initialised */ 
    int total_tiles = (d * d) - 1; 

    /* loop 2D array with outer loop row: fill tiles one by one 
    left to right (column) then top to bottom (rows)*/ 
    for (int index_row = 0; index_row < d ; index_row++) 
    { 
     for (int index_column = 0; index_column < d ; index_column++) 
     { 
      board [index_row][index_column] = total_tiles; 
      total_tiles--; 
     } 
     printf("\n"); 
    } 

    /* if d even, the number of tiles odd, then swap tile 1 and 2 */ 
    if (((d*d) - 1) % 2 != 0) 
    { 
     int temp = board[d-1][d-2]; 
     board[d-1][d-2] = board[d-1][d-3]; 
     board[d-1][d-3] = temp; 
    } 
     /* mark where your empty tile is */ 
     blank_row = d-1; 
     blank_column = d-1; 
} 

/** 
* Prints the board in its current state. 
*/ 
void draw(void) 
{ 
    /* Print the board, if tile 0 print underscore */ 
    for (int index_row = 0; index_row < d; index_row++) 
    { 
     for (int index_column = 0; index_column < d; index_column++) 
     { 
      if (board[index_row][index_column] < 10) 
      { 
       if (board[index_row][index_column] == 0) 
       { 
       printf(" [_] "); 
       } 
       else 
       { 
       printf(" [%d] ", board[index_row][index_column]); 
       } 
      } 
      else 
      { 
      printf("[%d] ", board[index_row][index_column]); 
      } 
     } 
     /* print space before printing next line */ 
     printf("\n"); 
    } 
} 

/** 
* If tile borders empty space, moves tile and returns true, else 
* returns false. 
*/ 
bool move(int tile) 
{ 
    /* sanity check for tile's existance */ 
    if (tile > (d*d)-1 || tile < 1) 
     return false; 

    /* linear search for tile inputted by user */ 
    search(tile); 

    /* Once we found the tile, we swap if move is legal */ 
    if (legalmove()) 
    { 
     swaptile(tile); 
     return true; 
    } 
    else 
     return false; 

    return false; 
} 

/** 
* Returns true if game is won (i.e., board is in winning configuration), 
* else false. 
*/ 
bool won(void) 
{ 
    /*set counter and check if last tile empty */ 
    int counter = 1; 

    /* Check if every tile corresponds to the an arthmetic sequence start = 1, constant = +1 */ 
    for(int index_row = 0; index_row < d; index_row++) 
    { 
     for(int index_column = 0; index_column < d; index_column++) 
     { 
      if (board[index_row][index_column] == counter) 
       counter++; 
     } 
    } 

    if (counter == d*d && board[d-1][d-1] == 0) 
     return true; 
    else 
     return false; 
} 

/* linear search for tile */ 
void search(int tile) 
{ 
    for (int index_row = 0; index_row < d; index_row++) 
    { 
     for(int index_column = 0; index_column < d; index_column++) 
     { 
      /* if tile found */ 
      if (board[index_row][index_column] == tile) 
      { 
       tile_row = index_row; 
       tile_column = index_column; 
      } 
     } 
    } 
} 

/* check if blank space bordering with the tile found*/ 
bool legalmove(void) 
{ 
    /* check if space on top row */ 
    if (tile_row > 0 && board[tile_row - 1][tile_column] == 0) 
     return true; 
    /* bottom */ 
    if (tile_row < d - 1 && board[tile_row + 1][tile_column] == 0) 
     return true; 
    /* left */ 
    if (tile_column > 0 && board[tile_row][tile_column - 1] == 0) 
     return true; 
    /* right */ 
    if (tile_column < d - 1 && board[tile_row][tile_column + 1] == 0) 
     return true; 
    else 
     return false; 
} 

/* swap and update tile position */ 
void swaptile(tile) 
{ 
    int temp = board[tile_row][tile_column]; 
    board[tile_row][tile_column] = board[blank_row][blank_column]; 
    board[blank_row][blank_column] = temp; 

    blank_row = tile_row; 
    blank_column = tile_column; 
} 

Answer 1

Sie die Warnung erhalten, weil in swaptile die tile Parameter tatsächlich nicht verwendet (selbst überprüfen) und weil Sie mit -Wunused-parameter kompiliert haben:

/* swap and update tile position */ 
void swaptile(tile) 
{ 
    /* tile parameter is not used in this function */ 

    int temp = board[tile_row][tile_column]; 
    board[tile_row][tile_column] = board[blank_row][blank_column]; 
    board[blank_row][blank_column] = temp; 

    blank_row = tile_row; 
    blank_column = tile_column; 
} 

... und es ist tatsächlich ein Fehler, weil Sie mit -Werror zusammengestellt, die alle Warnungen als Fehler betrachtet.

Sou Sie sollten nur haben

void swaptile() 

statt

void swaptile(tile) 

BTW: void swaptile(tile)void swaptile(int tile) sein sollte, (implizite int-Typen in Funktionsdeklarationen etwas depcrecated sind und einige Compiler nicht einmal akzeptieren es mehr).