Not understanding why context creation failing with win32 api and OpenGL and wgl
<p>So i have followed all of the fundamental instructions in windows creation for OpenGL rendering context </p>

<p>the problem is to do when i try to create a core profile context with opengl , it fails and i get the "the program stopped working" message from windows when i run the a.exe file, there is no indication where the problem exists and what is causing the problem , i even tried to run gdb but it only refers to the function </p>

<p>wglCreateContextAttribsARB and no other information is given </p>

<p>here is my files which are currently included in the program </p>

<p>mainWin.c </p>

<pre><code>#include "mainWin.h"
#include "glPart.c"



//main function, point of entry for windows application 
//must be present in a windows application

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
               LPSTR lpCmdLine, int nCmdShow)
{
   MSG        Msg;  //variable for storing messages retrieved from operating system by using GetMessage
   HWND       hWnd;
   WNDCLASS   WndCls;

   // Create the window object
   //sends a WM_CREATE message to windows which doesnt get processed until you retrieve messages and process them 

   //initialize window class must be initialized no default class 
   initWinClass(&amp;WndCls, hInstance);
   //Register the application must register application to make it available to other controls 
   RegisterClass(&amp;WndCls);

   hWnd = CreateWindow(ClsName,
                       WndName,
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       640,
                       640,
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   //printf("at initialization %x\n",hWnd);

   // Find out if the window was created
   if( !hWnd ) // If the window was not created,
      return 0; // stop the application

   printf("Window was created....\n");   

   // Display the window to the user
   ShowWindow(hWnd, SW_SHOWNORMAL);
   UpdateWindow(hWnd);

   initGL(hDC);

   //GLint a, b;

   while (Msg.message != WM_QUIT)
   {
      while (PeekMessage (&amp;Msg, NULL, 0, 0, PM_REMOVE) &gt; 0) //Or use an if statement
      {
          TranslateMessage (&amp;Msg);
          DispatchMessage (&amp;Msg);
      }
     //Here is were all the "animation that isn't used when the user does something" code will go.
      renderTri();
      SwapBuffers(hDC);
   }

   return Msg.wParam;
}
</code></pre>

<p>winMain.h</p>

<pre><code>#define true 1
#define false 0

#include &lt;windows.h&gt;
#include &lt;stdio.h&gt;
#include &lt;GL/glew.h&gt;
#include &lt;GL/wglew.h&gt;
#include &lt;GL/gl.h&gt;

LPCTSTR ClsName = "OpenGL App";
LPCTSTR WndName = "My Game";
//global hdc
HDC hDC;

PIXELFORMATDESCRIPTOR pfd = {
      sizeof(PIXELFORMATDESCRIPTOR),          //size of structure
      1,                                      //default version
      PFD_DRAW_TO_WINDOW |                    //window drawing support
      PFD_SUPPORT_OPENGL |                    //opengl support
      PFD_DOUBLEBUFFER,                       //double buffering support
      PFD_TYPE_RGBA,                          //RGBA color mode
      32,                                     //32 bit color mode
      0, 0, 0, 0, 0, 0,                       //ignore color bits
      0,                                      //no alpha buffer
      0,                                      //ignore shift bit
      0,                                      //no accumulation buffer
      0, 0, 0, 0,                             //ignore accumulation bits
      24,                                     //16 bit z-buffer size
      8,                                      //stencil buffer
      0,                                      //no aux buffer
      PFD_MAIN_PLANE,                         //main drawing plane
      0,                                      //reserved
      0, 0, 0 };                              //layer masks ignored

//context attributes
int attribs[] =
{
   WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
   WGL_CONTEXT_MINOR_VERSION_ARB, 1,
   WGL_CONTEXT_FLAGS_ARB, 0,
   WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, 
   0
};


LRESULT CALLBACK WndProcedure(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

void initWinClass(PWNDCLASS WndCls, HINSTANCE hInstance){

   // Create the application window
   //WndCls.cbSize        = sizeof(WNDCLASSEX); wndclassex
   WndCls-&gt;style         = CS_HREDRAW | CS_VREDRAW |CS_OWNDC;  
   //the style member variable specifies the primary operations applied on the window class
   //if user moves or changes its size, you would need the window redrawn to get its characteristics 
   //CS_HREDRAW CS_VREDRAW draw the window vertically and horizontally  
   WndCls-&gt;lpfnWndProc   = WndProcedure;
   WndCls-&gt;cbClsExtra    = 0;
   WndCls-&gt;cbWndExtra    = 0;
   WndCls-&gt;hIcon         = LoadIcon(NULL, IDI_APPLICATION);
   WndCls-&gt;hCursor       = LoadCursor(NULL, IDC_ARROW);
   WndCls-&gt;hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); //cast to HBRUSH 
   WndCls-&gt;lpszMenuName  = NULL;
   WndCls-&gt;lpszClassName = ClsName;
   WndCls-&gt;hInstance     = hInstance;
   //WndCls.hIconSm       = LoadIcon(NULL, IDI_APPLICATION); wndclassex

}

void setupPixelFormat(HDC hDC){

   int nPixelFormat;

   /*      Choose best matching format*/
   nPixelFormat = ChoosePixelFormat(hDC, &amp;pfd);

   if (nPixelFormat == 0) printf("Error in choose pixel format\n");

   /*      Set the pixel format to the device context*/
   BOOL bResult = SetPixelFormat(hDC, nPixelFormat, &amp;pfd);

   if (!bResult) printf("Error in set pixel format\n");


}

void setupPixelFormatARB(HDC hDC){

   const int attribList[] =
   {
     WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
     WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
     WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
     WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
     WGL_COLOR_BITS_ARB, 32,
     WGL_DEPTH_BITS_ARB, 24,
     WGL_STENCIL_BITS_ARB, 8,
     0,        //End
   };

   int pixelFormat;
   UINT numFormats;

   wglChoosePixelFormatARB(hDC, attribList, NULL, 1, &amp;pixelFormat, &amp;numFormats);
   SetPixelFormat(hDC, pixelFormat, &amp;pfd);


}

LRESULT CALLBACK WndProcedure(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
   //printf("the message %d memory address is %x\n", Msg, hWnd);   

   static HGLRC hRC;

    switch(Msg)
    {
    //this is the favourite message you can use to perform any early processing that you want to make 
    //sure happens before most things show up you can use this message to initialize anything in your application
    //The window procedure of the new window receives this message after the window is created, 
    //but before the window becomes visible.
    //will only run once on creation
    case WM_CREATE:
       hDC = GetDC(hWnd);   //get the device context for window
       setupPixelFormat(hDC); //call our pixel format setup function

       //in order to use ARB context creation you must create a render context
       //must be made active and destroyed 
       HGLRC tempContext = wglCreateContext(hDC);
       wglMakeCurrent(hDC, tempContext);

       hRC = wglCreateContextAttribsARB(hDC,0, attribs);
       wglMakeCurrent(NULL, NULL);
       wglDeleteContext(tempContext);
       wglMakeCurrent(hDC, hRC);

      wglMakeCurrent(hDC,hRC);  //make rendering context current old style
    break;

    //minimum application needs to deal with: 
    //wm_destroy message to close window and default case for non registered default messaging processing
    //otherwise hanging or not reaching event queue  

    case WM_DESTROY: //Sent when a window is being destroyed. 
                     //It is sent to the window procedure of the window being destroyed after the window is removed from the screen.
    //you can use this message to deconstruct the window once the user requests to destroy the window
       wglMakeCurrent(hDC,NULL);    //deselect rendering context
       wglDeleteContext(hRC);       //delete rendering context
       PostQuitMessage(0);      //The PostQuitMessage function posts a WM_QUIT message to the thread's message queue and returns immediately
       //send wm_quit message 
       //Indicates a request to terminate an application, and is generated when the application calls the PostQuitMessage function. 
       //This message causes the GetMessage function to return zero.
       printf("Window destroyed goodbye...bye");
    break;

    //this must exist to process left over messages or the application will hang or will not go forward through the 
    //event queue and the while loop will 
    default:
        // Process the left-over messages and messages that are not dealt with
       return DefWindowProc(hWnd, Msg, wParam, lParam);
    break;
    }
    // If something was not done, let it go
    return 0;
}
</code></pre>

<p>and finally glPart.c</p>

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;GL/glew.h&gt;
#include &lt;GL/gl.h&gt;

void initGL(HDC hDC){

   //set experimental value to true so that all functions can be used
       glewExperimental = GL_TRUE;

       //initialize glew and get result , check result is not a failure 
       GLenum err = glewInit();
       if(err!=GLEW_OK){
          printf("glew failed!!!....");     
       }

   //wglGetProcAddress("wglGetExtensionsStringARB")

   printf("OpenGL version string is %s\n", glGetString(GL_VERSION));

   GLint OpenGLVersion[3];

   glGetIntegerv(GL_MAJOR_VERSION, &amp;OpenGLVersion[0]);
   glGetIntegerv(GL_MINOR_VERSION, &amp;OpenGLVersion[1]);

   printf("Glew version is %s\n", glewGetString(GLEW_VERSION));
   printf("GL Major version %d\nGL Minor Version %d\n", OpenGLVersion[0], OpenGLVersion[1]);
   printf("GLSL version is %s \nVendor of OpenGL is %s \nRenderer version is %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION), 
                                                                                    glGetString(GL_VENDOR) ,glGetString(GL_RENDERER));
   // Enable settings 
   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

}
void renderTri(){

   //finally some drawing OpenGL

   GLuint vao;
   glGenVertexArrays(1, &amp;vao);
   glBindVertexArray(vao);

   // An array of 3 vectors which represents 3 vertices
   static const GLfloat verticies[] = {
     -1.0f, -1.0f, 0.0f,
      1.0f, -1.0f, 0.0f,
      0.0f,  1.0f, 0.0f,
   };

   // This will identify our vertex buffer
   GLuint vbo;
   // Generate 1 buffer, put the resulting identifier in vertexbuffer
   glGenBuffers(1, &amp;vbo);
   // The following commands will talk about our 'vertexbuffer' buffer
   glBindBuffer(GL_ARRAY_BUFFER, vbo);
   // Give our vertices to OpenGL.
   glBufferData(GL_ARRAY_BUFFER, sizeof(verticies), verticies, GL_STATIC_DRAW);

   // 1rst attribute buffer : vertices
   glEnableVertexAttribArray(0);
   glBindBuffer(GL_ARRAY_BUFFER, vbo);
   glVertexAttribPointer(
      0,                  // attribute 0. No particular reason for 0, but must match the layout in the shader.
      3,                  // size
      GL_FLOAT,           // type
      GL_FALSE,           // normalized?
      0,                  // stride
      (void*)0            // array buffer offset
   );
   // Draw the triangle !
   glDrawArrays(GL_TRIANGLES, 0, 3); // Starting from vertex 0; 3 vertices total -&gt; 1 triangle
   glDisableVertexAttribArray(0);

}
</code></pre>

<p>now if i do this the old way without wglCreateContextAttribsARB it works fine and does what it is supposed to do even without the shaders , but when i try to do this by creating a core profile context with wgl is when the program fails </p>

<p>i compile with </p>

<pre><code>gcc -Wall -Werror mainWin.c -lopengl32 -lglew32 -lgdi32
</code></pre>

<p>and no error are given </p>