c++ - 为什么我的子类被认为是抽象类？

Question

因此，对于我的下一款游戏，我正在创建类来改进游戏的架构 我有一个名为 GameState 的抽象类，所有 GameStates(菜单、窗口、屏幕、游戏本身)都必须继承它才能添加到游戏中，但是我的 BlankState 是对我的 GameState 设计的测试，这让我遇到了编译器的麻烦，因为它是，出于某种原因，被认为是一个抽象类，谁能告诉我为什么？我觉得我在这里遗漏了一些非常明显的东西。

这是GameState.h的内容

#ifndef GUARD_GAMESTATE_H
#define GUARD_GAMESTATE_H

#include<SDL.h>

class Game;

class GameState {
protected:
    Game *m_pGame;
public:
    GameState( Game&  );

    virtual void load() = 0;

    virtual void handle_events( SDL_Event& events ) = 0;
    virtual void logic() = 0;
    virtual void draw() = 0;

    virtual void unload() = 0;

    virtual ~GameState() = 0;
};

class BlankState : public GameState {
private:
    SDL_Surface *background;

public:

    BlankState(Game& game);

    void load();
    void handle_events();

    void logic();

    void draw();

    void unload();

    ~BlankState();
};

#endif

这是我在其中实现 GameState 构造函数和 BlankStates 继承方法的 GameState.cpp

#include"GameState.h"
#include"Game.h"
#include"AssetLoader.h"


GameState::GameState(Game& game) {
    m_pGame = &game;
    m_pGame->addState(this);
}




BlankState::BlankState(Game& game)
        :GameState(game)
    {}


void BlankState::load() {
        background = AssetLoader::loadImage("assets\background.png");
}

void BlankState::handle_events() {}

void BlankState::logic() {}

void BlankState::draw() {
        SDL_Rect lol;
        lol.x = 0;
        lol.y = 0;
        SDL_BlitSurface(background, NULL, m_pGame->getSurface(), &lol);
}

void BlankState::unload() {
        SDL_FreeSurface(background);
}

BlankState::~BlankState() {}

预先感谢您的帮助

Answer 1

派生类中的 void handle_events() 函数与它应该覆盖的基类中的 void handle_events(SDL_Event&) 函数具有不同的签名。

编译器提示是因为派生类没有提供在基类中声明的纯虚函数 void handle_events(SDL_Event&) 的实现。

换句话说，您的派生类是抽象的，编译器正确地拒绝实例化它。

作为补充说明，在 C++11 中，您可以使用上下文关键字 override 来明确说明您打算让成员函数覆盖在基类中声明的虚函数:

struct X
{
    virtual void foo(int) = 0;
};

struct Y : X
{
    virtual void foo(int) override { }
//                        ^^^^^^^^
//                        Makes it clear that this function is meant to
//                        override (and not just to hide) a virtual function 
//                        declared in the base class 
};

int main()
{
    Y y;
}

这样做的目的是可以很容易地发现像您所犯的错误。尝试覆盖一个函数，其签名与基类中虚函数的签名不兼容会触发编译错误:

struct X
{
    virtual void foo(int) = 0;
};

struct Y : X
{
    virtual void foo() override { } // ERROR!
    //                 ^^^^^^^^
    //                 X::foo has an incompatible signature
};

int main()
{
    Y y;
}