Problemy z obsługą błędów w kodzie C++

#include <cassert>
 
int GetArrayElement(int Index)
{
  assert(Index >= 0 && Index < g_ArraySize);
  return g_Array[Index];
}

int StrToInt(const std::string &s)
{
  return atoi(s.c_str());
}

Game::Game()
{
  m_MonsterTexture = LoadTexture("monster.tga");
  m_MonsterWidth = m_MonsterTexture->GetWidth();
  m_MonsterHeight = m_MonsterTexture->GetHeight();
}

HWND Wnd = CreateWindow("PROGRAM", "Program 1.0", WS_OVERLAPPEDWINDOW,
  CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  NULL, NULL, a_Instance, 0);
 
ShowWindow(Wnd, a_CmdShow);
UpdateWindow(Wnd);
 
MSG Msg;
ZeroMemory(&Msg, sizeof(Msg));
while (GetMessage(&Msg, NULL, 0, 0))
{
  TranslateMessage(&Msg);
  DispatchMessage(&Msg);
}

Game::Game()
{
  m_MonsterTexture = LoadTexture("monster.tga");
  if (m_MonsterTexture)
  {
    m_MonsterWidth = m_MonsterTexture->GetWidth();
    m_MonsterHeight = m_MonsterTexture->GetHeight();
  }
}

bool StrToInt(const std::string &s, int *Output);

bool g_Error = false;
 
Game::Game()
{
  m_MonsterTexture = LoadTexture("monster.tga");
  if (m_MonsterTexture)
  {
    m_MonsterWidth = m_MonsterTexture->GetWidth();
    m_MonsterHeight = m_MonsterTexture->GetHeight();
  }
  else
    g_Error = true;
}

Game::Game()
  LoadTexture()
    LoadFile()
      fopen
      fread
      fclose
    ParseLoadedData()
  LoadTexture()
    LoadFile()
      fopen
      fread
      fclose
    ParseLoadedData()
  ...

ParseLoadedData()
LoadTexture()
Game::Game()
...
WinMain()

void DrawAll()
{
  DrawBackground();
  DrawHorizon();
  DrawSprites();
  DrawParticles();
  DrawGUI();
}

void DrawSprites()
{
  int sprite_drawer_id = CreateSpriteDrawer();
  bool *arr = new int[g_Sprites.GetCount()];
  g_Sprites.FillArray(arr);
  VERTEX *v;
  SpriteDrawerLock(sprite_drawer_id, &v);
  for (int i = 0, index = 0; i < g_Sprites.GetCount(); i++)
  {
    if (arr[i])
    {
      v[index++] = SpriteToIndex(g_Sprites.GetSprite(i));
    }
  }
  SpriteDrawerUnlock(sprite_drawer_id);
  SpriteDrawerDraw(sprite_drawer_id);
  delete [] arr;
  DeleteSpriteDrawer(sprite_drawer_id);
}

#include <string>
#include <stack>
 
namespace err {
 
std::stack<std::string> g_Stack;
 
// Zwraca true, jeśli jest błąd
bool Is()
{
  return (!g_Stack.empty());
}
 
// Dodaje komunikat o błędzie
void Add(const std::string &a_Msg, const std::string &a_File,
  int a_Line)
{
  if (a_File.empty() && a_Line == 0)
    g_Stack.push(a_Msg);
  else if (a_File.empty())
    g_Stack.push("[" + IntToStr(a_Line) + "] " + a_Msg);
  else if (a_Line == 0)
    g_Stack.push("[" + a_File + "] " + a_Msg);
  else
    g_Stack.push("[" + a_File + "," + IntToStr(a_Line) + "] " + a_Msg);
}
 
// Czyści błąd
void Clear()
{
  while (!g_Stack.empty())
    g_Stack.pop();
}
 
// Zdejmuje ze stosu i zwraca pojedynczy komunikat błędu
// lub zwraca false, jeśli stos jest już pusty
bool Pop(std::string *a_Msg)
{
  if (g_Stack.empty())
    return false;
  else {
    *a_Msg = g_Stack.top();
    g_Stack.pop();
    return true;
  }
}
 
// Zwraca wszystkie błędy jako jeden łańcuch i czyści błąd
// Zwraca false, jeśli nie było błędu
bool PopAll(std::string *a_Messages)
{
  a_Messages->clear();
 
  if (!Is())
    return false;
  else {
    std::string s;
    while (Pop(&s)) {
      if (a_Messages->empty())
        (*a_Messages) += '\n';
      (*a_Messages) += s;
    }
    return true;
  }
}
 
} // namespace err

void DrawAll()
{
  DrawBackground();
  if (!err::Is())
  {
    DrawHorizon();
    if (!err::Is())
    {
      DrawSprites();
      if (!err::Is())
      {
        DrawParticles();
        if (!err::Is())
        {
          DrawGUI();
        }
      }
    }
  }
 
  if (err::Is())
    err::Add("Nie można odrysować gry", __FILE__, __LINE__);
}

void DrawAll()
{
  DrawBackground();
  if (!err::Is())
    DrawHorizon();
  if (!err::Is())
    DrawSprites();
  if (!err::Is())
    DrawParticles();
  if (!err::Is())
    DrawGUI();
 
  if (err::Is())
    err::Add("Nie można odrysować gry", __FILE__, __LINE__);
}

void DrawAll()
{
  DrawBackground();
  if (err::Is()) goto error;
  DrawHorizon();
  if (err::Is()) goto error;
  DrawSprites();
  if (err::Is()) goto error;
  DrawParticles();
  if (err::Is()) goto error;
  DrawGUI();
  if (err::Is()) goto error;
 
  return;
 
error:
  err::Add("Nie można odrysować gry", __FILE__, __LINE__);
}

void DrawSprites()
{
  int sprite_drawer_id = CreateSpriteDrawer();
  if (!err::Is())
  {
    bool *arr = new int[g_Sprites.GetCount()];
    g_Sprites.FillArray(arr);
    if (!err::Is())
    {
      VERTEX *v;
      SpriteDrawerLock(sprite_drawer_id, &v);
      if (!err::Is())
      {
        for (int i = 0, index = 0; i < g_Sprites.GetCount(); i++)
        {
          if (arr[i])
          {
            v[index++] = SpriteToIndex(g_Sprites.GetSprite(i));
            if (err::Is())
              break;
          }
        }
        SpriteDrawerUnlock(sprite_drawer_id);
      }
      if (!err::Is())
        SpriteDrawerDraw(sprite_drawer_id);
    }
    delete [] arr;
    DeleteSpriteDrawer(sprite_drawer_id);
  }
 
  if (err::Is())
    err::Add("Nie można odrysować sprites", __FILE__, __LINE__);
}

#include <string>
#include <stack>
 
namespace err {
 
class Error
{
private:
  /// Stack of error messages
  std::stack<std::string> m_Msgs;
 
protected:
  /** Use rhis constructor if you need to compute something before creating
  first error message and can't call constructor of this base class
  on the constructor initialization list */
  Error() { }
 
public:
  /// Push a message on the stack
  /** Use __FILE__ for file and __LINE__ for line */
  void Add(const std::string &msg, const std::string &file = "", int line = 0);
  /// Pop message from the top of the stack or return false if empty
  bool Pop(std::string *msg);
 
  /// General error creation
  Error(const std::string &msg, const std::string &file = "", int line = 0)
  {
    Add(msg, file, line);
  }
};
 
void Error::Add(const std::string &msg, const std::string &file, int line)
{
  if (msg.empty()) return;
 
  std::string file_name = ExtractFileName(file);
  if (file_name.empty() && line == 0)
    m_Msgs.push(msg);
  else if (file_name.empty())
    m_Msgs.push("[" + IntToStr(line) + "] " + msg);
  else if (line == 0)
    m_Msgs.push("[" + file_name + "] " + msg);
  else
    m_Msgs.push("[" + file_name + "," + IntToStr(line) + "] " + msg);
}
 
bool Error::Pop(std::string *msg)
{
  if (m_Msgs.empty())
    return false;
  else
  {
    *msg = m_Msgs.top();
    m_Msgs.pop();
    return true;
  }
}
 
} // namespace err

void DrawAll()
{
  try
  {
    DrawBackground();
    DrawHorizon();
    DrawSprites();
    DrawParticles();
    DrawGUI();
  }
  catch(err::Error &e)
  {
    e.Add("Nie można odrysować gry", __FILE__, __LINE__);
    throw;
  }
}

void DrawSprites()
{
  try
  {
    int sprite_drawer_id = CreateSpriteDrawer();
    try
    {
      bool *arr = new int[g_Sprites.GetCount()];
      try
      {
        g_Sprites.FillArray(arr);
        VERTEX *v;
        SpriteDrawerLock(sprite_drawer_id, &v);
        try
        {
          for (int i = 0, index = 0; i < g_Sprites.GetCount(); i++)
          {
            if (arr[i])
            {
              v[index++] = SpriteToIndex(g_Sprites.GetSprite(i));
            }
          }
          SpriteDrawerUnlock(sprite_drawer_id);
        }
        catch(...)
        {
          SpriteDrawerUnlock(sprite_drawer_id);
          throw;
        }
        SpriteDrawerDraw(sprite_drawer_id);
        delete [] arr;
      }
      catch(...)
      {
        delete [] arr;
        throw;
      }
      DeleteSpriteDrawer(sprite_drawer_id);
    }
    catch(...)
    {
      DeleteSpriteDrawer(sprite_drawer_id);
      throw;
    }
  }
  catch(err::Error &e)
  {
    e.Add("Nie można odrysować sprites", __FILE__, __LINE__);
    throw;
  }
}

CreateSth();
try
{
  // Może zgłosić błąd
  UseSth();
}
finally
{
  DeleteSth();
}

#include <fstream>
 
void foo()
{
  std::ifstream plik("dane.bin");
  // Może zgłosić błąd
  WczytajPlik(plik);
 
  // Błąd czy nie błąd, przy wyjściu z tej funkcji zmienna plik przestaje
  // istnieć, a w jej destruktorze plik zostaje zamknięty.
}

#include <memory>
 
void bar()
{
  std::auto_ptr<Klasa> wskaznik = std::auto_ptr<Klasa>(new Klasa());
  // Może zgłosić błąd
  UzywajObiektu(wskaznik);
 
  // Błąd czy nie błąd, przy wyjściu z tej funkcji zmienna wskaznik przestaje
  // istnieć, a w jej destruktorze utworzony dynamicznie obiekt klasy Klasa,
  // na który wskaźnik pokazuje, zostaje zwolniony.
}

void Create_DirectX(HRESULT hr, const std::string &Msg,
  const std::string &File, int Line)
{
  Add("(DirectX," + UintToStr(hr) + ") " + std::string(DXGetErrorString9(hr)) +
    " (" + std::string(DXGetErrorDescription9(hr)) + ")");
  if (!Msg.empty())
    Add(Msg, File, Line);
}

HRESULT hr = m_SavedDeviceState->Apply();
if (FAILED(hr))
  err::Create_DirectX(hr, "Nie można przywrócić ustawień urządzenia",
    __FILE__, __LINE__);

class Error_DirectX : public Error
{
public:
  Error_DirectX(HRESULT hr, const std::string &msg,
    const std::string &file, int line)
  {
    Add("(DirectX," + UintToStr(hr) + ") " + std::string(DXGetErrorString9(hr))
      + " (" + std::string(DXGetErrorDescription9(hr)) + ")");
    if (!Msg.empty())
      Add(msg, file, line);
  }
};

HRESULT hr = m_SavedDeviceState->Apply();
if (FAILED(hr))
  throw err::Error_DirectX(hr, "Nie można przywrócić ustawień urządzenia",
    __FILE__, __LINE__);