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.cpp，我实现了GameState构造函数和BlankStates继承的方法

#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;
}

这样做的目的是像你所做的那样的错误可能很容易被抓住。试图override一个签名与基类中的虚函数签名不兼容的函数会触发编译错误：

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

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

1 个答案: