c - 错误: unused parameter 'tile'

Question

我尝试了所有方法，但我的十五人游戏距离编译仅差一个错误。唯一的问题是，不知怎的，我得到了“未使用的参数错误”，告诉我我的代码没有使用tile参数......它应该!错误如下:

<小时/>

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

void swaptile(tile)
1 error generated.

<小时/>

这是代码

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

您收到警告是因为在 swaptile 中，tile 参数实际上未使用(检查一下自己)，并且因为您使用 进行编译-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 进行编译，它将所有警告视为错误。

所以你应该拥有

void swaptile()

而不是

void swaptile(tile)

顺便说一句:void swaptile(tile)应该是void swaptile(inttile)，(函数声明中的隐式int类型在某种程度上已被弃用，有些编译器甚至不这样做接受它吧)。