エラー：未使用のパラメータ 'tile'

Question

私はすべてを試しましたが、私のGame of 15はコンパイルされてから1つのエラーです。 唯一の問題は、何らかの理由で私のコードがタイルパラメータを使用していないことを私に伝える "未使用のパラメータエラー"が発生するということです。ここ は誤りです：

---

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

void swaptile(tile) 
1 error generated. 

---

そして、ここでは（自分で確認してください）swaptileにtileパラメータが実際にを使用していないので、あなたが警告を受けるコード

/** 
* 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

だと-Wunused-parameterでコンパイルしたため：

/* 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; 
} 

...すべての警告をエラーとみなす-Werrorでコンパイルしたため、実際にはエラーです。

壮介あなただけBTW代わり

void swaptile(tile) 

の

void swaptile() 

を持っている必要があります。void swaptile(tile)はvoid swaptile(int tile)、（関数宣言で暗黙のint型は多少depcrecatedされ、いくつかのコンパイラでも受け入れないでなければなりませんそれ以上）。