Code fails to run

// Code from Figs. 3.25 3.26 3.27 3.28 
// and page 101 of Hill, F.S. "Computer Graphics Using
// OpenGL", 2nd edition, Prentice Hall, NJ, 2001.
// Modified Sept. 2002 by B.G. Nickerson into more
// structured C++ code.
// Code from Figs. 3.25 3.26 3.27 3.28 
// and page 101 of Hill, F.S. "Computer Graphics Using
// OpenGL", 2nd edition, Prentice Hall, NJ, 2001.
// Modified Sept. 2002 by B.G. Nickerson into more
// structured C++ code.

#include<glut.h>
#include<math.h>
#include<iostream.h>
#include <stdlib.h>
using namespace std;

class Point2   //single point w/ floating point coordinates
{
public:
	Point2() {x = y = 0.0f;} //constructor 1
	Point2(float xx, float yy) {x=xx; y=yy;} //constructor 2
	void set(float xx, float yy) {x=xx; y=yy;}
	float getX() {return x;}
	float getY() {return y;}
	void draw(void)
	{
		glBegin(GL_POINTS); //draw this point
		glVertex2f((GLfloat)x, (GLfloat)y);
		glEnd();
	}
private:
	float x, y;
};


//<<Support Classes for Canvas>>>


class IntRect  //aligned rectangle with integer coordinates, used for viewport
{
public:
	IntRect() {l = 0; r=100; b=0; t=100;} //constructors
	IntRect(int left, int right, int bottom, int top)
		{l = left; r=right; b=bottom; t=top;}
	void set(int left, int right, int bottom, int top)
	{
		l=left; r=right; b=bottom; t=top;
	}
	void draw(void); //draw this rectangle using OpenGL
	int getL(void)
	{
		return l;
	}
	int getR(void)
	{
		return r;
	}
	int getT(void)
	{
		return t;
	}
	int getB(void)
	{
		return b;
	}

private:
	int l, r, b, t;
};

class RealRect   //simlar to IntRect but w/ floating points & used for world window
{
public:
	RealRect() {l = 0; r=100; b=0; t=100;} //constructors
	RealRect(float left, float right, float bottom, float top)
		{l = left; r=right; b=bottom; t=top;}
	void set(float left, float right, float bottom, float top)
	{
		l=left; r=right; b=bottom; t=top;
	}
	float getL(void)
	{
		return l;
	}
	float getR(void)
	{
		return r;
	}
	float getT(void)
	{
		return t;
	}
	float getB(void)
	{
		return b;
	}
	void draw(void); //draw this rectangle using OpenGL
private:
	float l, r, b, t;
};


//<<End Support Classes>>>

class Canvas
{
public:
	Canvas(int width, int height, char* windowTitle); //constructor
        void setWindow(float l, float r, float b, float t);
        void setViewport(int l, int r, int b, int t);
        IntRect getViewport(void); //divulge the viewport data
        RealRect getWindow(void); // divulge the window data
        float getWindowAspectRatio(void);
        void clearScreen();
        void setBackgroundColor(float r, float g, float b);
        void setColor(float r, float g, float b);
        void lineTo(float x, float y);
        void lineTo(Point2 p);
        void moveTo(float x, float y);
        void moveTo(Point2 p);
	void moveRel(float dx, float dy);
	void turnTo(float angle);
	void turn(float angle);
	void forward(float dist, int isVisible);
        Point2 Tween(Point2 A, Point2 B, float t);
        void drawTween(Point2 A[], Point2 B[], int N, float t);

private:
     Point2 CP;         //current position in the world
     IntRect viewport;  //the current window
     RealRect window;   //the current viewport
     float CD;          //current direction in degrees (for turtle)
} ;



// Constructor
Canvas:: Canvas(int width, int height, char* windowTitle)
{
	char* argv[1];  //dummy argument list for glutinit()
	char dummyString[8];
	argv[0] = dummyString;  //hook up the pointer
	int argc = 1;

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
	glutInitWindowSize(width, height);
	glutInitWindowPosition (20,20);
	glutCreateWindow (windowTitle);
	setWindow(0, (float)width, 0, (float)height); // default world window
	setViewport (0, width, 0, height); //default viewport
	CP.set(0.0f, 0.0f); //initialize the cp to (0,0)
}

void Canvas:: moveTo(Point2 p)  //moves current point CP to point p object 
{
	float x1, y1;
	x1 = p.getX();
	y1 = p.getY();
	CP.set(x1, y1);
}

void Canvas:: forward(float dist, int isVisible)  //moves turtle forward by dist 
{
  const float RadPerDeg=0.017453293; //radians per degree
  float x = CP.getX() + dist * cos(RadPerDeg * CD);
  float y = CP.getY() + dist * sin(RadPerDeg * CD);
  if(isVisible)
    lineTo(x, y);
  else
    moveTo(x, y);
}

void Canvas:: turnTo(float angle)
{
	CD = angle;
}

void Canvas:: turn(float angle) {CD += angle;}

float Canvas:: getWindowAspectRatio(void)  //calculates aspect ratio of world window
{
	float width, height, aspectRatio;
	width = window.getR() - window.getL();
	height = window.getT() - window.getB();
	aspectRatio = width/height;
	return aspectRatio;
}

void Canvas:: moveRel(float dx, float dy)
{
	CP.set(CP.getX() + dx, CP.getY() + dy);
}

//<<setWindow>>
void Canvas:: setWindow (float l, float r, float b, float t)
{
	glMatrixMode (GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D ((GLdouble)l, (GLdouble)r, (GLdouble)b, (GLdouble)t);
	window.set (l, r, b, t);
}

//<<setViewport>>
void Canvas:: setViewport (int l, int r, int b, int t)
{
	glViewport(l, b, r-l, t-b);
	viewport.set (l, r, b, t);
}

RealRect Canvas:: getWindow(void)
{
	return window;
}

IntRect Canvas:: getViewport(void)
{
	return viewport;
}

void Canvas:: clearScreen(void)
{
	glClear(GL_COLOR_BUFFER_BIT);
}

void Canvas:: setBackgroundColor(float r, float g, float b)
{
	glClearColor(r, g, b, 0.0);   //4th variable level of transparency, may need to change 
}

void Canvas:: setColor(float r, float g, float b)
{
	glColor3f(r, g, b);
}

void Canvas:: lineTo(Point2 p)
{
	glBegin (GL_LINES);
		glVertex2f((GLfloat) CP.getX(), (GLfloat) CP.getY());
		glVertex2f((GLfloat) p.getX(), (GLfloat) p.getY());
	glEnd();
	CP.set(p.getX(), p.getY());
	glFlush();
}

//<<moveTo>>
//changes current point
void Canvas:: moveTo(float x, float y)
{
	CP.set(x, y);
}

//<<lineTo>>
//draws a line from current point to new point
void Canvas:: lineTo(float x, float y)
{
	glBegin(GL_LINES);
		glVertex2f((GLfloat) CP.getX(), (GLfloat) CP.getY());
		glVertex2f((GLfloat) x, (GLfloat) y); //draw the line
	glEnd();
	CP.set (x, y); //update current point to new point
	glFlush();
}

//<<drawTween>>
//draw the tween at time t between polylines A and B
Point2 Canvas:: Tween(Point2 A, Point2 B, float t)
{
  Point2 P;
  P.set(A.getX() + (B.getX() - A.getX())*t, A.getY() + (B.getY() - A.getY())*t);
  return P;
}

//<<drawTween>>
//draw the tween at time t between polylines A and B
void Canvas:: drawTween(Point2 A[], Point2 B[], int N, float t)
{
  for(int i = 0; i < N; i++)
    {
      Point2 P;
      P = Tween(A[i], B[i], t);
      if (i == 0) moveTo(P.getX(), P.getY());
      else  lineTo(P.getX(), P.getY());
    }
}
// Code from Figs. 3.25 3.26 3.27 3.28 
// and page 101 of Hill, F.S. "Computer Graphics Using
// OpenGL", 2nd edition, Prentice Hall, NJ, 2001.
// Modified Sept. 2002 by B.G. Nickerson into more
// structured C++ code.

// Code for example canvas, myDisplay, drawTween to 
// interpolate between two polyline representations
// of equal length.

Canvas cvs(640, 640, "Example of tweening"); //global canvas object

void myDisplay(void)
{
	cvs.setViewport(0, 640, 0, 640); 
        cvs.clearScreen();
        cvs.setWindow(0.0, 1.0, 0.0, 1.0);
  // Tween between two figures; a la Fig. 4.22, p.171
        Point2 A[10];
        Point2 B[10];
        A[0].set(0.2, 0.5);
        A[1].set(0.5, 0.35);
        A[2].set(0.8, 0.5);
        A[3].set(0.5, 0.2);
        A[4].set(0.2, 0.5);
        B[0].set(0.2, 0.2);
        B[1].set(0.2, 0.8);
        B[2].set(0.8, 0.8);
        B[3].set(0.8, 0.2);
        B[4].set(0.2, 0.2);
        float t = 0.0;
        int N = 10;   // Number of tweenings
        float tinc = 1.0/N;
        int vpsize = 640/(N+1);
        for (int i = 0; i <= N; i++)
	  {
            cvs.setViewport(i*vpsize,(i+1)*vpsize, (N/2)*vpsize, (N/2+1)*vpsize); 
            cvs.drawTween(A, B, 5, t);
            t = t + tinc;
          }
}
// Code from Figs. 3.25 3.26 3.27 3.28 
// and page 101 of Hill, F.S. "Computer Graphics Using
// OpenGL", 2nd edition, Prentice Hall, NJ, 2001.
// Modified Sept. 2002 by B.G. Nickerson into more
// structured C++ code.

// example of using canvas class with tweening.

int main(int argc, char **argv)
{
	cvs.setWindow(-1.0, 1.0, -1.0, 1.0);
	cvs.setViewport(0, 640, 0, 640); 
	cvs.setBackgroundColor(1.0, 1.0, 1.0);
	cvs.setColor(0.0, 0.0, 0.0);
	
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutDisplayFunc(myDisplay);
	glutMainLoop();
	
        return 0;
}

1>c:\program files (x86)\microsoft visual studio 9.0\vc\include\stdlib.h(371) : warning C4985: 'exit': attributes not present on previous declaration.
1>        c:\program files (x86)\microsoft visual studio 9.0\vc\include\gl\glut.h(146) : see declaration of 'exit'