Anwendungsdesign in C++11/C++14

[unknown user]

Hallo,

ich habe mir Gedanken gemacht zur einer "möglichen" Implementierung eines Frameworks für meine Anwendungen (GUI App, Spiel). Bislang bin ich aber mit dem Design nicht glücklich...und würde mal ganz gerne eure Kritik und /oder Anregungen hören. Das Design ist sehr stark an Doom 3 (BFG) angelehnt, aber meiner Meinung nach Objektorientierter.

//////////////////////////////////////////////////////////////////////////////
class Foo
{
public:
    virtual ~Foo() = default;

public:
    virtual void Init() = 0;
    virtual void Shutdown() = 0;
};

class FooLocal: public Foo
{
public:
    FooLocal();

public:
    virtual ~FooLocal();

public:
    virtual void Init();
    virtual void Shutdown();
};

FooLocal::FooLocal()
{
    std::cout << "FooLocal ctor" << std::endl;
}

FooLocal::~FooLocal()
{
    std::cout << "FooLocal dtor" << std::endl;
}

void FooLocal::Init()
{
    std::cout << "FooLocal Init" << std::endl;
}

void FooLocal::Shutdown()
{
    std::cout << "FooLocal Shutdown" << std::endl;
}
//////////////////////////////////////////////////////////////////////////////
class Goo
{
public:
    virtual ~Goo() = default;

public:
    virtual void Init() = 0;
    virtual void Shutdown() = 0;
};

class GooLocal: public Goo
{
public:
    GooLocal();

public:
    virtual ~GooLocal();

public:
    virtual void Init();
    virtual void Shutdown();
};

GooLocal::GooLocal()
{
    std::cout << "GooLocal ctor" << std::endl;
}

GooLocal::~GooLocal()
{
    std::cout << "GooLocal dtor" << std::endl;
}

void GooLocal::Init()
{
    std::cout << "GooLocal Init" << std::endl;
}

void GooLocal::Shutdown()
{
    std::cout << "GooLocal Shutdown" << std::endl;
}
//////////////////////////////////////////////////////////////////////////////
class Boo
{
public:
    virtual ~Boo() = default;

public:
    virtual void Init() = 0;
    virtual void Shutdown() = 0;
};

class BooLocal: public Boo
{
public:
    BooLocal();

public:
    virtual ~BooLocal();

public:
    virtual void Init();
    virtual void Shutdown();
};

BooLocal::BooLocal()
{
    std::cout << "BooLocal ctor" << std::endl;
}

BooLocal::~BooLocal()
{
    std::cout << "BooLocal dtor" << std::endl;
}

void BooLocal::Init()
{
    std::cout << "BooLocal Init" << std::endl;
}

void BooLocal::Shutdown()
{
    std::cout << "BooLocal Shutdown" << std::endl;
}

//////////////////////////////////////////////////////////////////////////////
class Doo
{
public:
    virtual ~Doo() = default;

public:
    virtual void Init() = 0;
    virtual void Shutdown() = 0;
};

class DooLocal: public Doo
{
public:
    DooLocal();

public:
    virtual ~DooLocal();

public:
    virtual void Init();
    virtual void Shutdown();
};

DooLocal::DooLocal()
{
    std::cout << "DooLocal ctor" << std::endl;
}

DooLocal::~DooLocal()
{
    std::cout << "DooLocal dtor" << std::endl;
}

void DooLocal::Init()
{
    std::cout << "DooLocal Init" << std::endl;
}

void DooLocal::Shutdown()
{
    std::cout << "DooLocal Shutdown" << std::endl;
}
//////////////////////////////////////////////////////////////////////////////
class Moo
{
public:
    virtual ~Moo() = default;

public:
    virtual void Init() = 0;
    virtual void Shutdown() = 0;
};

class MooLocal: public Moo
{
public:
    MooLocal();

public:
    virtual ~MooLocal();

public:
    virtual void Init();
    virtual void Shutdown();
};

MooLocal::MooLocal()
{
    std::cout << "MooLocal ctor" << std::endl;
}

MooLocal::~MooLocal()
{
    std::cout << "MooLocal dtor" << std::endl;
}

void MooLocal::Init()
{
    std::cout << "MooLocal Init" << std::endl;
}

void MooLocal::Shutdown()
{
    std::cout << "MooLocal Shutdown" << std::endl;
}
//////////////////////////////////////////////////////////////////////////////
class Roo
{
public:
    virtual ~Roo() = default;

public:
    virtual void Init() = 0;
    virtual void Shutdown() = 0;
};

class RooLocal: public Roo
{
public:
    RooLocal();

public:
    virtual ~RooLocal();

public:
    virtual void Init();
    virtual void Shutdown();
};

RooLocal::RooLocal()
{
    std::cout << "RooLocal ctor" << std::endl;
}

RooLocal::~RooLocal()
{
    std::cout << "RooLocal dtor" << std::endl;
}

void RooLocal::Init()
{
    std::cout << "RooLocal Init" << std::endl;
}

void RooLocal::Shutdown()
{
    std::cout << "RooLocal Shutdown" << std::endl;
}
//////////////////////////////////////////////////////////////////////////////
// DLL???
// statische Bibliothek????
class Game
{
public:
    virtual ~Game() = default;

public:
    virtual void Init() = 0;
};

namespace globals{
    extern Game *const game;
}

class GameLocal: public Game
{
public:
    virtual ~GameLocal();

public:
    virtual void Init();
};

GameLocal::~GameLocal()
{
    // dtor
}

void GameLocal::Init()
{
    std::cout << "GameLocal Init" << std::endl;
}

namespace globals{
    extern GameLocal gamelocal;
}
//////////////////////////////////////////////////////////////////////////////
// DLL???
// statische Bibliothek????

struct GameImport
{
    int version;
    Foo *foo;
    Goo *goo;
    Boo *boo;
    Doo *doo;
    Moo *moo;
    Roo *roo;
};

struct GameExport
{
    int version;
    Game *game;
};
//////////////////////////////////////////////////////////////////////////////
// Globale Funktionsdeklaration...
GameExport* GetGameApi(GameImport *const import);

////////////////////////////////////////////
namespace{
    GameExport game_export;

    Foo *foo {};
    Goo *goo {};
    Boo *boo {};
    Doo *doo {};
    Moo *moo {};
    Roo *roo {};

    Game *game {};
}

// Globale Funktionsdefinition...
GameExport* GetGameApi(GameImport *const import)
{
    foo = import->foo;
    goo = import->goo;
    boo = import->boo;
    doo = import->doo;
    moo = import->moo;
    roo = import->roo;

    game_export.game = globals::game;
    return &game_export;
}
//////////////////////////////////////////////////////////////////////////////

class App
{
public:
    virtual ~App() = default;

public:
    virtual void Init() = 0;
    virtual void Run() = 0;
    virtual void Shutdown() = 0;
};

namespace globals{
    extern App *const app;
}

class AppLocal: public App
{
public:
    AppLocal();
    AppLocal(const AppLocal &) = delete;
    AppLocal& operator=(const AppLocal &) = delete;

public:
    virtual ~AppLocal();

public:
    virtual void Init();
    virtual void Run();
    virtual void Shutdown();

private:
    // Subsysteme
    FooLocal foo_;
    GooLocal goo_;
    BooLocal boo_;
    DooLocal doo_;
    MooLocal moo_;
    RooLocal roo_;
};

AppLocal::AppLocal():
    foo_ (),
    goo_ (),
    boo_ {},
    doo_ {},
    moo_ {},
    roo_ {}
{
    std::cout << "AppLocal ctor"  << std::endl;
}

AppLocal::~AppLocal()
{
    std::cout << "AppLocal dtor"  << std::endl;
}

void AppLocal::Init()
{
    std::cout << "AppLocal Init"  << std::endl;

    foo_.Init();
    goo_.Init();
    boo_.Init();
    doo_.Init();
    moo_.Init();
    roo_.Init();

    Foo* foo = &foo_;
    Goo* goo = &goo_;
    Boo* boo = &boo_;

    GameImport game_import;
    game_import.foo = foo;
    game_import.boo = boo;
    game_import.goo = goo;

    GameExport* game_export = GetGameApi(&game_import);

    game = game_export->game;
}

void AppLocal::Run()
{
    std::cout << "AppLocal Run"  << std::endl;
}

void AppLocal::Shutdown()
{
    // Exceptions...
    foo_.Shutdown();
    goo_.Shutdown();
    boo_.Shutdown();
    doo_.Shutdown();
    moo_.Shutdown();
    roo_.Shutdown();
}
//////////////////////////////////////////////////////////////////////////////

namespace globals{
    extern AppLocal applocal;
}

//////////////////////////////////////////////////////////////////////////////

namespace globals{
    AppLocal applocal;
    App *const app = &applocal;

    GameLocal gamelocal;
    Game *const game = &gamelocal;
}

int WINAPI WinMain(
                HINSTANCE,
                HINSTANCE,
                LPSTR,
                int)
{
    globals::app->Init();
    globals::app->Run();
    globals::app->Shutdown();

    return EXIT_SUCCESS;
}

Bislang gilt ja das Design von Doom3 / Doom3 BFG als sehr einfach zu lesen und zu verstehen, auch nach Aussagen z. B. von Fabien Sanglard.
Ich frage mich auch ob ich das Ganze nicht mehr in richtung C++11 / C++14
drücken sollte?

Gruß