my window's handle is unused and cannot be evaluated

I am trying to encapsulate my Win32 application into a class. My problem occurs when trying to initiate my primary window for the application below is my declaration and implementation... I notice the issue within my class method InitInstance();

declaration

#pragma once
#include "stdafx.h"
#include "resource.h"
#define MAX_LOADSTRING 100

class RenderEngine {
protected:
    int m_width;
    int m_height;

    ATOM RegisterEngineClass();

public:
    static HINSTANCE m_hInst;
    HWND m_hWnd;
    int m_nCmdShow;
    TCHAR m_szTitle[MAX_LOADSTRING];                    // The title bar text
    TCHAR m_szWindowClass[MAX_LOADSTRING];          // the main window class name

    bool InitWindow();
    bool InitDirectX();
    bool InitInstance();

    //static functions
    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
    static INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);

    int Run();

};

implementation

#include "stdafx.h"
#include "RenderEngine.h"
HINSTANCE RenderEngine::m_hInst = NULL;

bool RenderEngine::InitWindow()
{
    RenderEngine::m_hInst = NULL;
    // Initialize global strings
    LoadString(m_hInst, IDS_APP_TITLE, m_szTitle, MAX_LOADSTRING);
    LoadString(m_hInst, IDC_RENDERENGINE, m_szWindowClass, MAX_LOADSTRING);

    if(!RegisterEngineClass())
    {
        return false;
    }

    if(!InitInstance())
    {
        return false;
    }

    return true;
}

ATOM RenderEngine::RegisterEngineClass()
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = RenderEngine::WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = m_hInst;
    wcex.hIcon          = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_RENDERENGINE));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_RENDERENGINE);
    wcex.lpszClassName  = m_szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassEx(&wcex);
}

LRESULT CALLBACK RenderEngine::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;

    switch (message)
    {
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        // Parse the menu selections:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(m_hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        // TODO: Add any drawing code here...
        EndPaint(hWnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message,开发者_C百科 wParam, lParam);
    }
    return 0;
}

bool RenderEngine::InitInstance()
{
   m_hWnd = NULL;// When I step into my code it says on this line 0x000000 unused = ??? expression cannot be evaluated
   m_hWnd = CreateWindow(m_szWindowClass, m_szTitle, WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, m_hInst, NULL);

   if (!m_hWnd)// At this point, memory has been allocated unused = ??. It steps over this
   {
      return FALSE;
   }

   if(!ShowWindow(m_hWnd, m_nCmdShow))// m_nCmdShow = 1 and m_hWnd is still unused and expression
   {//Still cannot be evaluated. This statement is true. and shuts down.
        return false;
   }
   UpdateWindow(m_hWnd);

   return true;
}

// Message handler for about box.
INT_PTR CALLBACK RenderEngine::About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

int RenderEngine::Run()
{
    MSG msg;
    HACCEL hAccelTable;

    hAccelTable = LoadAccelerators(m_hInst, MAKEINTRESOURCE(IDC_RENDERENGINE));

    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}

and my winMain function that calls the class

// RenderEngine.cpp : Defines the entry point for the application.
#include "stdafx.h"
#include "RenderEngine.h"

// Global Variables:

RenderEngine go;

    int APIENTRY _tWinMain(HINSTANCE hInstance,
                         HINSTANCE hPrevInstance,
                         LPTSTR    lpCmdLine,
                         int       nCmdShow)
    {
        UNREFERENCED_PARAMETER(hPrevInstance);
        UNREFERENCED_PARAMETER(lpCmdLine);

        // TODO: Place code here.
        RenderEngine::m_hInst = hInstance;
        go.m_nCmdShow = nCmdShow;
        if(!go.InitWindow())
        {
            return 0;
        }
            go.Run();

        return 0;
    }

---

ShowWindow returns 0 if the window was previously invisible, so !ShowWindow(m_hWnd, m_nCmdShow) evaluates to true, causing your InitInstance to return false.

As to all this "unused" stuff from the debugger, did you compile in Debug mode?