Weird array behavior in classes along with Windows DCs (C++)?

Question

I'm working on creating a text based Windows game, and I am having a problem (I guess) with arrays not working the same within a class scope as within the main function. As far as I can tell it is some kind of interaction between a larger array class member (or large total amount of variables) and Windows creating a DC or other Windows API calls and/or variables.

What I want to do is a have a class called Map that contains a two dimensional array of Tiles. Tile is just a simple struct with basic tile information. I would like to make the array 256 x 256. This shouldn't be a problem as far as I can figure. Each Tile should be 32 bytes. That's 2 MB total for the array.

However, the game crashes when I declare a variable of the Map class in the main function, and then do things with Windows DCs. The return value seems to vary, In the current form, it usually returns 255, but I have also gotten "process terminated with status -1073741571". A 128 x 128 array does work in the class though. It also works fine if I remove either the array or the code in DisplayScreen. And as I implied, it also works if I just move the array of Tiles to the main function.

I'm honestly baffled. I have no idea what the difference would be. Nothing is going out of scope. Doesn't matter if it is a public or private member. Non dynamic class members should all get declared on the stack and it shouldn't work any differently in a class versus otherwise, right?

For other information, I am using Code::Blocks with the Min GW compiler. Everything is up to date. I am running Windows 10. My computer specs shouldn't be an issue either, but if it matters, I have 16 GB memory and a 4Ghz Athlon FX 8 core processor.

Edit: Here is the full code, so nothing is left out

Game.h:

#ifndef GAME_H_INCLUDED
#define GAME_H_INCLUDED

struct Tile
{
    char chr[2];
    int  r[2], b[2], g[2];

    bool solid;
    bool translucent;
    int  opacity;
};

class Map
{
    Tile tileMap[256][256];

public:
    Map();

};

Map::Map()
{
    int i, j;

    for(i=0;i<256;i++)
    {
        for(j=0;j<256;j++)
        {
            tileMap[i][j].chr[0] = 'X';
            tileMap[i][j].b[0] = 255;
            tileMap[i][j].r[0] = 255;
            tileMap[i][j].g[0] = 255;

            tileMap[i][j].chr[1] = ' ';
            tileMap[i][j].b[1] = 0;
            tileMap[i][j].r[1] = 0;
            tileMap[i][j].g[1] = 0;

            tileMap[i][j].solid = false;
            tileMap[i][j].translucent = false;
            tileMap[i][j].opacity = 255;
        }
    }
}

main.cpp:

#include <windows.h>
#include "Game.h"

#define FRAMERATE 60

//Function declarations
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
void DisplayScreen(HWND pWnd, Map &pMap);

//Make the class name into a global variable
char strClassName[ ] = "GameApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpstrArgument,
                    int nCmdShow)
{
    HWND hWnd;               //This is the handle for our window
    MSG messages;            //Here messages to the application are saved
    WNDCLASSEX wndClassEx;   //Data structure for the windowclass

    Map test;

    DWORD  sysTimer;
    DWORD  sysPrevTime = 0;
    DWORD  timerDelta = 1000 / FRAMERATE;

    //Get a handle for the whole screen
    HDC hDC = GetDC(NULL);

    //Initalize the Window structure
    wndClassEx.hInstance = hThisInstance;
    wndClassEx.lpszClassName = strClassName;
    wndClassEx.lpfnWndProc = WindowProcedure;
    wndClassEx.style = CS_DBLCLKS;
    wndClassEx.cbSize = sizeof (WNDCLASSEX);
    wndClassEx.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wndClassEx.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wndClassEx.hCursor = LoadCursor (NULL, IDC_ARROW);
    wndClassEx.lpszMenuName = NULL;                 //No menu
    wndClassEx.cbClsExtra = 0;
    wndClassEx.cbWndExtra = 0;
    wndClassEx.hbrBackground = CreateSolidBrush(RGB(0,0,0));

    //Register the window class, and if it fails quit the program
    if (!RegisterClassEx (&wndClassEx))
        return 0;

    //Create Window with registered window class
    hWnd = CreateWindowEx (
        0,                           
        strClassName,                //Class name
        "Game Test",                 //Title Text
        WS_OVERLAPPEDWINDOW,         //default window type
        0,                           //X pos of window at top left
        0,                           //Y pos of window at top left
        GetDeviceCaps(hDC, HORZRES), //Set window width to screen width
        GetDeviceCaps(hDC, VERTRES), //Set window height to screen height
        HWND_DESKTOP,                //Child-window to desktop
        NULL,                        //No menu
        hThisInstance,               //Program Instance handler
        NULL);                       //No Window Creation data


    //Removes borders from the window
    SetWindowLong(hWnd, GWL_STYLE, WS_POPUP);
    //Make the window visible on the screen
    ShowWindow (hWnd, nCmdShow);

    //Run the message and game loop
    while (true)
    {
        while(PeekMessage(&messages,NULL,0,0, PM_REMOVE))
        {
            if (messages.message == WM_QUIT)
            {
                ReleaseDC(NULL, hDC);
                DestroyWindow(hWnd);
                return 0;
            }

            TranslateMessage(&messages);
            DispatchMessage(&messages);
        }

        sysTimer = timeGetTime();

        if (sysTimer >= (sysPrevTime + timerDelta) )
        {
            sysPrevTime = sysTimer;
            DisplayScreen(hWnd, test);
        }

    }
}

//This function is called by the Windows function DispatchMessage()
LRESULT CALLBACK WindowProcedure (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_DESTROY:
            PostQuitMessage (0); //Send WM_QUIT to the message queue
            break;

        default:
            return DefWindowProc (hWnd, message, wParam, lParam);
    }

    return 0;
}

void DisplayScreen(HWND pWnd, Map &pMap)
{
    HDC hDC = GetWindowDC(pWnd);
    HDC hdcBuf = CreateCompatibleDC(hDC);

    HBITMAP hbmBuf = CreateCompatibleBitmap(hDC, 800, 600);
    HFONT hMapFont = CreateFont(17,11,0,0,400,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH | FF_MODERN,"Lucida Console");
    HFONT hTxtFont = CreateFont(17,11,0,0,400,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,ANTIALIASED_QUALITY,DEFAULT_PITCH | FF_MODERN,"Lucida Console");

    SelectObject(hdcBuf, hbmBuf);
    SelectObject(hdcBuf, hMapFont);

    SetBkColor(hdcBuf, RGB(0,0,0));
    SetTextColor(hdcBuf, RGB(255,255,255));

    //Draw to the buffer
    TextOut(hdcBuf, 10, 10, "Hello World   @", 15);

    //Tranfers the buffer to the Screen
    BitBlt(hDC, 100, 100, 800, 600, hdcBuf, 0, 0, SRCCOPY);

    //Release all object handles
    DeleteObject(hTxtFont);
    DeleteObject(hMapFont);
    DeleteObject(hbmBuf);

    DeleteDC(hdcBuf);
    ReleaseDC(pWnd, hDC);
}

It crashes with even one instance of something creating a DC. It works fine otherwise creating and destroying the DCs and displaying the bitmap over and over again even if I leave it for an hour. Once I create that class with the large array in it though, it just dies.

I actually used to have the Display function as a class function and I moved it out because I thought that was the problem, but it wasn't.

Interestingly, if I change the declaration from 'Map test;' to 'Map* test = new Map;' and change the rest of the program appropriately, it works. Honestly though, doing that just seems kind of dumb, and I think that would slow everything down if I don't have a good reason to put everything on the heap. Plus, I don't like bandages. If there is a problem I'd rather fix it.

Any ideas?

Answer 1

You have a stack overflow (the condition, not the website).

Answer 2

The problem can be reproduced in this program:

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
    Map test;
    return 0;
}

It fails because it reaches stack limit.

Also tileMap[i][j].chr[2] is out of bound. It is declared as char chr[2]; valid index is 0 and 1. It can only go up to tileMap[i][j].chr[1]

Ditto b[], r[], and g[]

Change the Map class so that it allocates memory on heap and fix chr:

class Map
{
    //Tile tileMap[256][256];
    Tile **tileMap;
public:
    Map();
    ~Map();
};

Map::Map()
{
    int i, j;

    tileMap = new Tile*[256];
    for (i = 0; i < 256; i++)
        tileMap[i] = new Tile[256];

    for (i = 0; i<256; i++)
    {
        for (j = 0; j<256; j++)
        {
            //tileMap[i][j].chr[1] = 'X';
            tileMap[i][j].chr[0] = 'X';  //<== meant to be 0?
            tileMap[i][j].b[0] = 255;
            tileMap[i][j].r[0] = 255;
            tileMap[i][j].g[0] = 255;

            //tileMap[i][j].chr[2] = ' ';
            tileMap[i][j].chr[1] = ' '; //<== meant to be 1?
            tileMap[i][j].b[1] = 0;
            tileMap[i][j].r[1] = 0;
            tileMap[i][j].g[1] = 0;

            tileMap[i][j].solid = false;
            tileMap[i][j].translucent = false;
            tileMap[i][j].opacity = 255;
        }
    }
}

Map::~Map()
{
    int i = 0;
    for (i = 0; i < 256; i++)
        delete[]tileMap[i];
    delete[]tileMap;
}