title: C++ Directx Error: Access Violation, swapchain was nullptr
body: <p>I'm trying to learn 3D Drawing with DirectX and i got this Code in a Tutorial, but every time i try and compile it, my compiler gives out a "Access Violation swapchain was nullptr" Error.</p>
  
  <p>Thanks in advance</p>
  
  <pre><code>   // include the basic windows header files and the Direct3D header files
      #include &lt;windows.h&gt;
      #include &lt;windowsx.h&gt;
      #include &lt;d3d11.h&gt;
      #include &lt;d3dx11.h&gt;
      #include &lt;d3dx10.h&gt;
  
      // include the Direct3D Library file
      #pragma comment (lib, "d3d11.lib")
      #pragma comment (lib, "d3dx11.lib")
      #pragma comment (lib, "d3dx10.lib")
  
      // global declarations
      IDXGISwapChain *swapchain;             // the pointer to the swap chain interface
      ID3D11Device *dev;                     // the pointer to our Direct3D device interface
      ID3D11DeviceContext *devcon;           // the pointer to our Direct3D device context
      ID3D11RenderTargetView *backbuffer;    // the pointer to our back buffer
  
      // function prototypes
      void InitD3D(HWND hWnd);    // sets up and initializes Direct3D
      void RenderFrame(void);     // renders a single frame
      void CleanD3D(void);        // closes Direct3D and releases memory
  
      // the WindowProc function prototype
      LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
  
  
      // the entry point for any Windows program
      int WINAPI WinMain(HINSTANCE hInstance,
                         HINSTANCE hPrevInstance,
                         LPSTR lpCmdLine,
                         int nCmdShow)
      {
          HWND hWnd;
          WNDCLASSEX wc;
  
          ZeroMemory(&amp;wc, sizeof(WNDCLASSEX));
  
          wc.cbSize = sizeof(WNDCLASSEX);
          wc.style = CS_HREDRAW | CS_VREDRAW;
          wc.lpfnWndProc = WindowProc;
          wc.hInstance = hInstance;
          wc.hCursor = LoadCursor(NULL, IDC_ARROW);
          wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
          wc.lpszClassName = L"WindowClass";
  
          RegisterClassEx(&amp;wc);
  
          RECT wr = {0, 0, 800, 600};
          AdjustWindowRect(&amp;wr, WS_OVERLAPPEDWINDOW, FALSE);
  
          hWnd = CreateWindowEx(NULL,
                                L"WindowClass",
                                L"Our First Direct3D Program",
                                WS_OVERLAPPEDWINDOW,
                                300,
                                300,
                                wr.right - wr.left,
                                wr.bottom - wr.top,
                                NULL,
                                NULL,
                                hInstance,
                                NULL);
  
          ShowWindow(hWnd, nCmdShow);
  
          // set up and initialize Direct3D
          InitD3D(hWnd);
  
          // enter the main loop:
  
          MSG msg;
  
          while(TRUE)
          {
              if(PeekMessage(&amp;msg, NULL, 0, 0, PM_REMOVE))
              {
                  TranslateMessage(&amp;msg);
                  DispatchMessage(&amp;msg);
  
                  if(msg.message == WM_QUIT)
                      break;
              }
  
              RenderFrame();
          }
  
          // clean up DirectX and COM
          CleanD3D();
  
          return msg.wParam;
      }
  
  
      // this is the main message handler for the program
      LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
      {
          switch(message)
          {
              case WM_DESTROY:
                  {
                      PostQuitMessage(0);
                      return 0;
                  } break;
          }
  
          return DefWindowProc (hWnd, message, wParam, lParam);
      }
  
  
      // this function initializes and prepares Direct3D for use
      void InitD3D(HWND hWnd)
      {
          // create a struct to hold information about the swap chain
          DXGI_SWAP_CHAIN_DESC scd;
  
          // clear out the struct for use
          ZeroMemory(&amp;scd, sizeof(DXGI_SWAP_CHAIN_DESC));
  
          // fill the swap chain description struct
          scd.BufferCount = 1;                                    // one back buffer
          scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;     // use 32-bit color
          scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;      // how swap chain is to be used
          scd.OutputWindow = hWnd;                                // the window to be used
          scd.SampleDesc.Count = 1;                               // how many multisamples
          scd.SampleDesc.Quality = 0;                             // multisample quality level
          scd.Windowed = TRUE;                                    // windowed/full-screen mode
  
          // create a device, device context and swap chain using the information in the scd struct
          D3D11CreateDeviceAndSwapChain(NULL,
                                        D3D_DRIVER_TYPE_HARDWARE,
                                        NULL,
                                        NULL,
                                        NULL,
                                        NULL,
                                        D3D11_SDK_VERSION,
                                        &amp;scd,
                                        &amp;swapchain,
                                        &amp;dev,
                                        NULL,
                                        &amp;devcon);
  
  
          // get the address of the back buffer
          ID3D11Texture2D *pBackBuffer;
          swapchain-&gt;GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&amp;pBackBuffer);
  
          // use the back buffer address to create the render target
          dev-&gt;CreateRenderTargetView(pBackBuffer, NULL, &amp;backbuffer);
          pBackBuffer-&gt;Release();
  
          // set the render target as the back buffer
          devcon-&gt;OMSetRenderTargets(1, &amp;backbuffer, NULL);
  
  
          // Set the viewport
          D3D11_VIEWPORT viewport;
          ZeroMemory(&amp;viewport, sizeof(D3D11_VIEWPORT));
  
          viewport.TopLeftX = 0;
          viewport.TopLeftY = 0;
          viewport.Width = 800;
          viewport.Height = 600;
  
          devcon-&gt;RSSetViewports(1, &amp;viewport);
      }
  
  
      // this is the function used to render a single frame
      void RenderFrame(void)
      {
          // clear the back buffer to a deep blue
          devcon-&gt;ClearRenderTargetView(backbuffer, D3DXCOLOR(0.0f, 0.2f, 0.4f, 1.0f));
  
          // do 3D rendering on the back buffer here
  
          // switch the back buffer and the front buffer
          swapchain-&gt;Present(0, 0);
      }
  
  
  // this is the function that cleans up Direct3D and COM
  void CleanD3D(void)
  {
      // close and release all existing COM objects
      swapchain-&gt;Release();
      backbuffer-&gt;Release();
      dev-&gt;Release();
      devcon-&gt;Release();
  }
  </code></pre>