title: Getting Rid of Black Console Window When Running C++ Application
body: <p>I am using Netbeans 7.1 to toy around with the AI tutorial I found <a href="http://www.ai-junkie.com/ann/evolved/nnt1.html" rel="nofollow">here</a>.</p>
  
  <p><strong>edit:</strong> I am using the GCC compiler.</p>
  
  <p>I've gotten everything working, but I can't seem to get the application to compile and run with the Windows Subsystem... The application appears to be written properly for Windows  API, and the executable that came with the source files from that website launches without producing the black console window that my own executable creates. </p>
  
  <p>I've tried adding <code>-mwindows</code> as an option to the linker, and I've tried <code>-Wl,-subsystem,windows</code>. Neither of these have worked for me. I've provided the main.cpp below. </p>
  
  <pre><code>#define WIN32_LEAN_AND_MEAN
  
  #include &lt;windows.h&gt; 
  
  #include &lt;stdlib.h&gt;
  #include &lt;time.h&gt;
  
  
  #include "utils.h"
  #include "CController.h"
  #include "CTimer.h"
  #include "resource.h"
  #include "CParams.h"
  
  
  // edited this out, still not working
  </code></pre>
  
  <p>// #pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")</p>
  
  <pre><code>///////////////////////GLOBALS ////////////////////////////////////
  
  char*           szApplicationName = "Smart Sweepers v1.0";
  char*           szWindowClassName = "sweeper";
  
  
  //The controller class for this simulation
  CController*    g_pController    = NULL; 
  
  //create an instance of the parameter class.
  CParams   g_Params;
  
  //---------------------------- Cleanup ----------------------------------
  //
  //  simply cleans up any memory issues when the application exits
  //-----------------------------------------------------------------------
  void Cleanup()
  {
      if (g_pController) 
  
          delete g_pController;
  }
  //-----------------------------------WinProc-----------------------------
  //
  //-----------------------------------------------------------------------
  LRESULT CALLBACK WindowProc(HWND hwnd, 
                                          UINT msg, 
                              WPARAM wparam, 
                              LPARAM lparam)
  {
      //these hold the dimensions of the client window area
      static int cxClient, cyClient;
  
      //used to create the back buffer
      static HDC        hdcBackBuffer;
      static HBITMAP  hBitmap;
      static HBITMAP  hOldBitmap; 
  
  
      switch(msg)
      {   
          case WM_CREATE: 
          {
              //seed the random number generator
              srand((unsigned) time(NULL));
  
              //get the size of the client window
              RECT rect;
              GetClientRect(hwnd, &amp;rect);
  
              cxClient = rect.right;
              cyClient = rect.bottom;
  
              //setup the controller
              g_pController = new CController(hwnd);
  
                  //create a surface for us to render to(backbuffer)
              hdcBackBuffer = CreateCompatibleDC(NULL);
  
              HDC hdc = GetDC(hwnd);
  
              hBitmap = CreateCompatibleBitmap(hdc,
                                                              cxClient,
                                                              cyClient);
              ReleaseDC(hwnd, hdc);
  
              hOldBitmap = (HBITMAP)SelectObject(hdcBackBuffer, hBitmap); 
          } 
  
          break;
  
          //check key press messages
          case WM_KEYUP:
          {
              switch(wparam)
              {
  
                  case VK_ESCAPE:
                  {
                      PostQuitMessage(0);
                  }
  
                  break;
  
                  case 'F':
                      {
                          g_pController-&gt;FastRenderToggle();
                      }
  
                      break;
  
          //reset the demo
          case 'R':
            {
               if (g_pController)
               {
                 delete g_pController;
               }
  
               //setup the new controller
                     g_pController = new CController(hwnd);
            }
  
            break;
  
              }//end WM_KEYUP switch
          }
  
          break;
  
          //has the user resized the client area?
          case WM_SIZE:
          {
              cxClient = LOWORD(lparam);
              cyClient = HIWORD(lparam);
  
              //resize the backbuffer accordingly
              SelectObject(hdcBackBuffer, hOldBitmap);
  
              HDC hdc = GetDC(hwnd);
  
              hBitmap = CreateCompatibleBitmap(hdc,
                                                               cxClient,
                                                               cyClient);
              ReleaseDC(hwnd, hdc);
  
              hOldBitmap = (HBITMAP)SelectObject(hdcBackBuffer, hBitmap); 
          } 
  
          break;
  
          case WM_PAINT: 
          {
        PAINTSTRUCT ps;
  
            BeginPaint(hwnd, &amp;ps);
  
              //fill our backbuffer with white
              BitBlt(hdcBackBuffer,
               0,
               0,
               cxClient,
               cyClient,
               NULL,
               NULL,
               NULL,
               WHITENESS);
  
              //render the mines and sweepers
              g_pController-&gt;Render(hdcBackBuffer);
  
              //now blit backbuffer to front
              BitBlt(ps.hdc, 0, 0, cxClient, cyClient, hdcBackBuffer, 0, 0, SRCCOPY); 
  
              EndPaint(hwnd, &amp;ps);
          } 
  
          break;
  
          case WM_DESTROY: 
          {
              SelectObject(hdcBackBuffer, hOldBitmap);
  
              //clean up our backbuffer objects
              DeleteDC(hdcBackBuffer);
              DeleteObject(hBitmap); 
  
        // kill the application, this sends a WM_QUIT message 
              PostQuitMessage(0);
          } 
  
          break;
  
          default:break;
  
      }//end switch
  
      // default msg handler 
      return (DefWindowProc(hwnd, msg, wparam, lparam));
  
  }//end WinProc
  
  
  //-----------------------------------WinMain-----------------------------------------
  //  Entry point for our windows application
  //-----------------------------------------------------------------------------------
  int WINAPI WinMain( HINSTANCE hinstance,
                                HINSTANCE hprevinstance,
                                LPSTR lpcmdline,
                                int ncmdshow)
  {
  
      WNDCLASSEX winclass; 
      HWND       hwnd;     
      MSG        msg;      
  
      // first fill in the window class stucture
      winclass.cbSize       = sizeof(WNDCLASSEX);
      winclass.style            = CS_HREDRAW | CS_VREDRAW;
      winclass.lpfnWndProc    = WindowProc;
      winclass.cbClsExtra     = 0;
      winclass.cbWndExtra     = 0;
      winclass.hInstance      = hinstance;
      winclass.hIcon            = LoadIcon(hinstance, MAKEINTRESOURCE(IDI_ICON1));
      winclass.hCursor          = LoadCursor(NULL, IDC_ARROW); 
      winclass.hbrBackground= NULL; 
      winclass.lpszMenuName   = NULL;
      winclass.lpszClassName= szWindowClassName;
      winclass.hIconSm      = LoadIcon(hinstance, MAKEINTRESOURCE(IDI_ICON1));
  
  
      // register the window class
      if (!RegisterClassEx(&amp;winclass))
      {
          MessageBox(NULL, "Error Registering Class!", "Error", 0);
      return 0;
      }
  
      // create the window (one that cannot be resized)
      if (!(hwnd = CreateWindowEx(NULL,                                   
                                                szWindowClassName,                        
                                                szApplicationName,                        
                                                WS_OVERLAPPED | WS_VISIBLE | WS_CAPTION | WS_SYSMENU,
                                GetSystemMetrics(SM_CXSCREEN)/2 - CParams::WindowWidth/2,
                                GetSystemMetrics(SM_CYSCREEN)/2 - CParams::WindowHeight/2,                                    
                                                CParams::WindowWidth,
                                CParams::WindowHeight,                
                                                NULL,                                 
                                                NULL,                             
                                                hinstance,                                
                                                NULL)))   
      {
      MessageBox(NULL, "Error Creating Window!", "Error", 0);
          return 0;
      }
  
      //Show the window
      ShowWindow(hwnd, SW_SHOWDEFAULT );
      UpdateWindow(hwnd);
  
      //create a timer
      CTimer timer(CParams::iFramesPerSecond);
  
      //start the timer
      timer.Start();
  
      // Enter the message loop
      bool bDone = FALSE;
  
      while(!bDone)
      {
  
          while( PeekMessage( &amp;msg, NULL, 0, 0, PM_REMOVE ) ) 
          {
              if( msg.message == WM_QUIT ) 
              {
                  //Stop loop if it's a quit message
                  bDone = TRUE;
              } 
  
              else 
              {
                  TranslateMessage( &amp;msg );
                  DispatchMessage( &amp;msg );
              }
          }
  
          if (timer.ReadyForNextFrame() || g_pController-&gt;FastRender())
          {   
            if(!g_pController-&gt;Update())
              {
                  //we have a problem, end app
                  bDone = TRUE;
              }
  
              //this will call WM_PAINT which will render our scene
              InvalidateRect(hwnd, NULL, TRUE);
              UpdateWindow(hwnd);
      }                   
  
      }//end while
  
  
      // Clean up everything and exit the app
      Cleanup();
      UnregisterClass( szWindowClassName, winclass.hInstance );
  
      return 0;
  
  } // end WinMain
  </code></pre>