Polymorphism

Polymorphism
You are encouraged to solve this task according to the task description, using any language you may know.

Create two classes Point and Circle with a polymorphic function

BASIC

Interpeter: QuickBasic 4.5, PB 7.1

C

Compiler: GCC, MSVC, BCC, Watcom

Libraries: Standard

 #if defined( _WIN32 ) || defined( MSC_VER )
 #define FN_PTR(x) (& x)
 #else
 #define FN_PTR(x) (x)
 #endif

 typedef struct Point
 {
   int x;
   int y;
   void (*print)();
 } Point;

 Point* Point_new0()
 {
   Point* pthis = (Point*) malloc( sizeof( Point ) );
   memset(pthis, 0, sizeof( Point ) );
   pthis->print = FN_PTR(Point_print);
 }

 Point* Point_new1(int x0)
 {
   Point* pthis = (Point*) malloc( sizeof( Point ) );
   pthis->x = x0;
   pthis->y = 0;
   pthis->print = FN_PTR(Point_print);
 }

 Point* Point_new2(int x0, int y0)
 {
   Point* pthis = (Point*) malloc( sizeof( Point ) );
   pthis->x = x0;
   pthis->y = y0;
   pthis->print = FN_PTR(Point_print);
 }

 Point* Point_copy(Point* p)
 {
   Point* pthis = (Point*) malloc( sizeof( Point ) );
   memcpy(pthis, p, sizeof( Point ) );
   return pthis;
 }

 int Point_getX(Point* pthis) { return pthis->x; }
 int Point_getY(Point* pthis) { return pthis->y; }
 int Point_setX(Point* pthis, int x0) { pthis->x = x0; }
 int Point_setY(Point* pthis, int y0) { pthis->y = y0; }
 void Point_print() { printf("Point\n"); }
 void Point_vprint(Point* pthis) { pthis->print(); }

 // Trick: This way Circle.x, Circle.y, Circle.r are available
 typedef union Circle
 {
   Point point;
   struct _Circle
   {
     Point point;
     int r;
   };
 } Circle;

 Circle* Circle_new0()
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   memset(pthis, 0, sizeof( Circle ) );
   pthis->print = FN_PTR(Circle_print);
 }

 Circle* Circle_new1(int x0)
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   pthis->x = x0;
   pthis->y = 0;
   pthis->r = 0;
   pthis->print = FN_PTR(Circle_print);
 }

 Circle* Circle_new2(int x0, int y0)
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   pthis->x = x0;
   pthis->y = y0;
   pthis->r = 0;
   pthis->print = FN_PTR(Circle_print);
 }

 Circle* Circle_new3(int x0, int y0, int r0)
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   pthis->x = x0;
   pthis->y = y0;
   pthis->r = r0;
   pthis->print = FN_PTR(Circle_print);
 }

 Circle* Circle_newP0(Point* p)
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   pthis->x = p->x;
   pthis->y = p->y;
   pthis->r = 0;
   pthis->print = FN_PTR(Circle_print);
 }

 Circle* Circle_newP1(Point* p, int r0)
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   pthis->x = p->x;
   pthis->y = p->y;
   pthis->r = r0;
   pthis->print = FN_PTR(Circle_print);
 }

 Circle* Circle_copy(Circle* c)
 {
   Circle* pthis = (Circle*) malloc( sizeof( Circle ) );
   memcpy(pthis, c, sizeof( Circle ) );
   return pthis;
 }

 int Circle_getX(Circle* pthis) { return pthis->x; }
 int Circle_getY(Circle* pthis) { return pthis->y; }
 int Circle_getR(Circle* pthis) { return pthis->r; }
 int Circle_setX(Circle* pthis, int x0) { pthis->x = x0; }
 int Circle_setY(Circle* pthis, int y0) { pthis->y = y0; }
 int Circle_setR(Circle* pthis, int r0) { pthis->r = r0; }
 void Circle_print() { printf("Circle\n"); }
 void Circle_vprint(Circle* pthis) { pthis->print(); }

C++

Compiler: GCC, Visual C++, BCC, Watcom

 class Point
 {
   protected:
     int x, y;
   public:
     Point(int x0 = 0, int y0 = 0) : x(x0), y(y0) {}
     Point(const Point& p) : x(p.x), y(p.y) {}
     virtual ~Point() {}
     const Point& operator=(const Point& p)
     {
       if(this != &p)
       {
         x = p.x;
         y = p.y;
       }
       return *this;
     }
     int getX() { return x; }
     int getY() { return y; }
     int setX(int x0) { x = x0; }
     int setY(int y0) { y = y0; }
     virtual void print() { printf("Point\n"); }
 };

 class Circle : public Point
 {
   private:
     int r;
   public:
     Circle(Point p, int r0 = 0) : Point(p), r(r0) {}
     Circle(int x0 = 0, int y0 = 0, int r0 = 0) : Point(x0, y0), r(r0) {}
     virtual ~Circle() {}
     const Circle& operator=(const Circle& c)
     {
       if(this != &c)
       {
         x = c.x;
         y = c.y;
         r = c.r;
       }
       return *this;
     }
     int getR() { return r; }
     int setR(int r0) { r = r0; }
     virtual void print() { printf("Circle\n"); }
 };

D

Compiler: DMD,GDC

Perl

Interpeter: Perl