为什么我的蛇只向上移动？ 我已经开始在C++中编写Snake了。这是到目前为止我的代码

main.cpp：

#include "game.hpp"

int main(void)
{
    Game game;

    int count = 0;  

    while(game.program_is_running)
    {
        game.key_events();

        if(count >= 3000)
        {
            game.tick();
            count = 0;
        }
        else
            count++;
    }

    return 0;
}

game.hpp：

#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <vector>

#include "snake.hpp"

#define NUMBER_OF_ROWS 25
#define NUMBER_OF_COLUMNS 25

class Game
{
public:

    Game(void);

    void tick(void);
    void key_events(void);

    bool program_is_running;

private:

    char grid[NUMBER_OF_ROWS][NUMBER_OF_COLUMNS];

    Snake snake;

    bool right_pressed, left_pressed, down_pressed, up_pressed;

    void display_grid(void);
};

Game::Game(void)
{
    for(int y = 0; y < NUMBER_OF_ROWS; y++)
    {
        for(int x = 0; x < NUMBER_OF_COLUMNS; x++)
        {
            if(y == 0 || y == NUMBER_OF_ROWS - 1)
                grid[y][x] = '#';
            else if(x == 0 || x == NUMBER_OF_COLUMNS - 1)
                grid[y][x] = '#';
            else
                grid[y][x] = ' ';
        }
    }

    program_is_running = true;

    right_pressed = false;
    left_pressed = false;
    down_pressed = false;
    up_pressed = false;
}

void Game::tick(void)
{
    for(int y = 0; y < NUMBER_OF_ROWS; y++)
    {
        for(int x = 0; x < NUMBER_OF_COLUMNS; x++)
        {
            if(y == 0 || y == NUMBER_OF_ROWS - 1)
                grid[y][x] = '#';
            else if(x == 0 || x == NUMBER_OF_COLUMNS - 1)
                grid[y][x] = '#';
            else
                grid[y][x] = ' ';
        }
    }

    std::vector<Block> snake_body = snake.get_body();

    if(right_pressed)
    {
        snake.move(0, 1);
    }
    else if(left_pressed)
    {
        snake.move(0, -1);
    }
    else if(down_pressed)
    {
        snake.move(1, 0);
    }
    else if(up_pressed)
    {
        snake.move(-1, 0);
    }

    for(int y = 0; y < NUMBER_OF_ROWS; y++)
    {
        for(int x = 0; x < NUMBER_OF_COLUMNS; x++)
        {
            for(int i = 0; i < snake_body.size(); i++)
            {
                if(snake_body[i].y == y && snake_body[i].x == x)
                {
                    grid[y][x] = snake.get_symbol();
                }
            }
        }
    }

    display_grid();
}

void Game::key_events(void)
{
    char c;

    if(kbhit())
    {
        c = _getch();

        switch(c)
        {
            case 'q':
                program_is_running = false;

            case 'l':
                left_pressed = false;
                down_pressed = false;
                up_pressed = false;
                right_pressed = true;

            case 'h':
                right_pressed = false;
                down_pressed = false;
                up_pressed = false;
                left_pressed = true;

            case 'j':
                right_pressed = false;
                left_pressed = false;
                up_pressed = false;
                down_pressed = true;

            case 'k':
                right_pressed = false;
                down_pressed = false;
                left_pressed = false;
                up_pressed = true;
        }
    }
}

void Game::display_grid(void)
{
    system("cls");

    for(int y = 0; y < NUMBER_OF_ROWS; y++)
    {
        for(int x = 0; x < NUMBER_OF_COLUMNS; x++)
        {
            std::cout << grid[y][x] << ' ';
        }

        std::cout << std::endl;
    }
}

#包括
#包括
#包括
#包括
#包括“snake.hpp”
#定义\u行的数量\u 25
#定义\u列的数量\u 25
班级游戏
{
公众：
游戏（无效）；
作废勾选（作废）；
作废关键事件（作废）；
bool程序正在运行；
私人：
字符网格[行数][列数]；
蛇；
按下右键，按下左键，按下下键，按下上键；
虚空显示网格（虚空）；
};
游戏：：游戏（无效）
{
对于（int y=0；y<行数；y++）
{
对于（int x=0；x<列数；x++）
{
if（y==0 | | y==u行数-1）
网格[y][x]='#'；
else if（x==0 | | x==u列数-1）
网格[y][x]='#'；
其他的
网格[y][x]=''；
}
}
程序运行=真；
右键按下=假；
左按=假；
按下按钮=错误；
向上按=假；
}
无效游戏：：勾选（无效）
{
对于（int y=0；y<行数；y++）
{
对于（int x=0；x<列数；x++）
{
if（y==0 | | y==u行数-1）
网格[y][x]='#'；
else if（x==0 | | x==u列数-1）
网格[y][x]='#'；
其他的
网格[y][x]=''；
}
}
std:：vector snake_body=snake.get_body（）；
如果（按下右键）
{
蛇。移动（0，1）；
}
否则，如果（按下左键）
{
snake.move（0，-1）；
}
否则，如果（按下按钮）
{
snake.move（1,0）；
}
否则，如果（向上按）
{
蛇形移动（-1,0）；
}
对于（int y=0；y<行数；y++）
{
对于（int x=0；x<列数；x++）
{
对于（int i=0；i
switch(c)
{
    case 'q':
        program_is_running = false;

    case 'l':
        left_pressed = false;
        down_pressed = false;
        up_pressed = false;
        right_pressed = true;

    case 'h':
        right_pressed = false;
        down_pressed = false;
        up_pressed = false;
        left_pressed = true;

    case 'j':
        right_pressed = false;
        left_pressed = false;
        up_pressed = false;
        down_pressed = true;

    case 'k':
        right_pressed = false;
        down_pressed = false;
        left_pressed = false;
        up_pressed = true;
}

一直到最后一个例子，
'k'
，所以你总是以

        right_pressed = false;
        down_pressed = false;
        left_pressed = false;
        up_pressed = true;

您应该在每个案例的末尾添加
break
，以避免出现这种情况

在风格方面，我想知道您是否可以将四个相互排斥的事件的四个布尔值折叠为一个标志，显示移动的值

您可以有一个查找表（无序映射或类似），将键映射到移动参数，只需调用
move
，而不需要switch语句。
开关

switch(c)
{
    case 'q':
        program_is_running = false;

    case 'l':
        left_pressed = false;
        down_pressed = false;
        up_pressed = false;
        right_pressed = true;

    case 'h':
        right_pressed = false;
        down_pressed = false;
        up_pressed = false;
        left_pressed = true;

    case 'j':
        right_pressed = false;
        left_pressed = false;
        up_pressed = false;
        down_pressed = true;

    case 'k':
        right_pressed = false;
        down_pressed = false;
        left_pressed = false;
        up_pressed = true;
}

一直到最后一个例子，
'k'
，所以你总是以

        right_pressed = false;
        down_pressed = false;
        left_pressed = false;
        up_pressed = true;

您应该在每个案例的末尾添加
break
，以避免出现这种情况

在风格方面，我想知道您是否可以将四个相互排斥的事件的四个布尔值折叠为一个标志，显示移动的值

您可以有一个查找表（无序映射或类似），将键映射到move参数，只需调用
move
，而不需要switch语句。
您没有break；在case:'结束后，switch语句将执行每一个case，因为“up”是最后一个案例，它将覆盖所有其他案例。
您没有break；在案例结束后：，因此您的switch语句将执行每个案例，因为“up”是最后一种情况，它将覆盖所有其他情况。
No
break
在
switch
中读取的可能副本启用警告的体面编译器会告诉您这一点。No
break
在
switch
中读取的可能副本启用警告的体面编译器会告诉您这一点。