title: "Cannot open include file: 'fstream.h'" error in Visual Studio 2008 Express Edition
body: <p>When compiling this code I get:</p>
  
  <p>fatal error C1083: Cannot open include file: 'fstream.h': No such file or directory</p>
  
  <p>Why? </p>
  
  <p>Code:</p>
  
  <pre><code>#include &lt;windows.h&gt;   // use as needed for your system
  
  #include &lt;gl/Gl.h&gt;
  #include &lt;gl/glut.h&gt;
  #include &lt;iostream&gt;
  #include &lt;fstream.h&gt;
  
  //**************Global Data
  char ifileName[30],oFileName[30];
  fstream inFile,outFile;
  
  //************ Data structure 
  struct GLfloatPoint
  { GLfloat x,y;
  };
  
  const int MAX = 100;
  class GLfloatPointArray
  {
  public:
    int num;
    GLfloatPoint pt[MAX];
  };
  
  //***************** subprograms
  typedef GLfloat colorType[3];
  // subprogram used to draw the control points separately
  void drawDot (GLfloat x, GLfloat y, GLfloat r, GLfloat g, GLfloat b)
  { glColor3f(r,g,b);
    glBegin (GL_POINTS);
        glVertex2f (x,y);
    glEnd();
  }
  // Drawing subprogram - this will draw the curve from a set of points
  void drawFloatPolyLine (GLfloatPointArray P, colorType c)
  { glColor3fv (c);
    glBegin(GL_LINE_STRIP);
     for (int i=0; i &lt; P.num; i++)
       glVertex2f (P.pt[i].x,P.pt[i].y);
    glEnd();
  }
  
  //******************** myInit 
   void myInit(void)
   {
      glClearColor(1.0,1.0,1.0,0.0);  // set white background color
      glColor3f (0.0f,0.0f,0.0f);    //default color
      glMatrixMode(GL_PROJECTION); 
      glLoadIdentity();
      gluOrtho2D(0.0, 640.0, 0.0, 480.0);
      // get data files
      cout &lt;&lt; "Enter the input file name: ";
      cin &gt;&gt; ifileName;
      inFile.open (ifileName,ios::in);
      if (inFile.fail())
        return;
      // if want to see points for debugging add output
      // cout &lt;&lt; "Enter the output file name: ";
      // cin &gt;&gt; oFileName;
      // outFile.open (oFileName,ios::out);
      // if (outFile.fail())
      //   return;
  }
  
  //***************** BEZIER Curve subprograms
  // Read the control points 
  void readControlPoints (GLfloatPointArray &amp;P)
  {
    inFile &gt;&gt; P.num;
    for (int j = 0; j &lt; P.num; j++)
      inFile &gt;&gt; P.pt[j].x &gt;&gt; P.pt[j].y;
  }
  // output control points to a text file - if you want to see the 
  // computations
  void printPointArray (GLfloatPointArray P)
  {
    outFile &lt;&lt; "Size: " &lt;&lt; P.num &lt;&lt; endl &lt;&lt; "Points:" &lt;&lt; endl;
    for (int j = 0; j &lt; P.num; j++)
      outFile &lt;&lt; "(" &lt;&lt; P.pt[j].x &lt;&lt; "," &lt;&lt; P.pt[j].y &lt;&lt; ")" &lt;&lt; endl;
  }
  
  const int MAXCONTPTS = 100;
  int c[MAXCONTPTS];   // the binomial coefficients
  //helper routines - compute the coefficient
  void ComputeCoeff (int n)
  { int j,k;
    for (k=0;k&lt;=n;k++)
    { //compute n! / (k!*(n-k)!)
      c[k] = 1;
      for (j = n;j&gt;=k+1;j--)
        c[k] *=j;
      for (j = n-k;j&gt;=2;j--)
        c[k] /= j;
    }
  }
  // compute the blending value
  float BlendingValue (int n, int k, float t)
  { int j;
    float bv;
    // compute  c[k]*t^k * (1-t)^(n-k)
    bv = c[k];
    for (j=1; j&lt;=k;j++)
      bv *= t;
    for (j = 1;j&lt;=n-k;j++)
      bv *= (1-t);
    return bv;
  }
  
  // compute one point on the Bezier curve - fixed value of t
  void ComputePoint (float t, int n, GLfloatPoint &amp; p, 
                     GLfloatPointArray ctrlPts)
  { int k;
    float b;
    p.x = 0.0;
    p.y = 0.0;
    for (k = 0; k&lt;=n;k++)
    {  b = BlendingValue (n,k,t);
       p.x += ctrlPts.pt[k].x*b;
       p.y  += ctrlPts.pt[k].y*b;
    }
  }
  // compute the array of Bezier points - drawing done separately
  void Bezier ( GLfloatPointArray controlPts, int numInter, 
                GLfloatPointArray &amp; curve)
  { // there are numContPts+1 control points and numInter t values to evaluate the curve
    int k;
    float t;
    ComputeCoeff (controlPts.num-1);
    curve.num = numInter+1;
    for (k=0; k&lt;=numInter; k++)
    { t = (float) k / (float) numInter;
      ComputePoint (t, controlPts.num-1,curve.pt[k],controlPts);
    }
  }
  
  //************************ myDisplay 
  void myDisplay(void)
  {  
     int numbCurves;
     GLfloatPointArray ControlPts,BezCurve;
     colorType C = {0.0f,1.0f,0.0f};
  
     glClear(GL_COLOR_BUFFER_BIT);     // clear the screen 
  
     inFile &gt;&gt; numbCurves;
     for (int i = 0; i &lt; numbCurves; i++)
     { 
       // read control points and draw them in red big points
       readControlPoints (ControlPts);
       glPointSize (4.0);
       for (int j = 0; j &lt; ControlPts.num; j++)
         drawDot (ControlPts.pt[j].x,ControlPts.pt[j].y,1,0,0);
       glPointSize (1.0);
       // Compute the Bezier curve points and draw
       Bezier (ControlPts,50,BezCurve);
         // draw the Bezier curve
       drawFloatPolyLine (BezCurve,C);
       glFlush ();
     }
  }
  
  //**************************** main
  void main(int argc, char** argv)
  {
      glutInit(&amp;argc, argv);          // initialize the toolkit
      glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // set display mode
      glutInitWindowSize(640,480);     // set window size
      glutInitWindowPosition(100, 150); // set window position on screen
      glutCreateWindow("Bezier Curve drawing"); // open the screen window
      glutDisplayFunc(myDisplay);     // register redraw function
      myInit();                   
      glutMainLoop();              // go into a perpetual loop
  }
  </code></pre>