//10. Наследяване на класове: базисни и производни класове; 
//защитени членове на клас; прехвърляне на указатели от базисния към 
//производния клас. 
//
// POINT.H
// Definition of class Point
#ifndef POINT_H
#define POINT_H

class Point {
   friend ostream &operator<<(ostream &, const Point &);
public:
   Point(float = 0, float = 0);      // default constructor
   void setPoint(float, float);      // set coordinates
   float getX() const { return x; }  // get x coordinate
   float getY() const { return y; }  // get y coordinate
protected:         // accessible by derived classes
   float x, y;     // x and y coordinates of the Point
};
#endif
------------------------
// POINT.CPP
// Member functions for class Point
#include <iostream.h>
#include "point.h"

// Constructor for class Point
Point::Point(float a, float b) { setPoint(a, b); }

// Set x and y coordinates of Point
void Point::setPoint(float a, float b){ x = a; y = b; }

// Output Point (with overloaded stream insertion operator)
ostream &operator<<(ostream &output, const Point &p)
{  output << '[' << p.x << ", " << p.y << ']';
   return output;   // enables concatenated calls
}
-----------------
// CIRCLE.H
// Definition of class Circle
#ifndef CIRCLE_H
#define CIRCLE_H

#include <iostream.h>
#include <iomanip.h>
#include "point.h"

class Circle : public Point {  // Circle inherits from Point
   friend ostream &operator<<(ostream &, const Circle &);
public:
   // default constructor
   Circle(float r = 0.0, float x = 0, float y = 0);

   void setRadius(float);      // set radius
   float getRadius() const;    // return radius
   float area() const;         // calculate area
protected:
   float radius;
};
#endif
---------------
// CIRCLE.CPP
// Member function definitions for class Circle
#include "circle.h"

// Constructor for Circle calls constructor for Point
// with a member initializer then initializes radius.
Circle::Circle(float r, float a, float b)
   : Point(a, b)       // call base-class constructor
{ radius = r; }

// Set radius of Circle
void Circle::setRadius(float r) { radius = r; }

// Get radius of Circle
float Circle::getRadius() const { return radius; }

// Calculate area of Circle
float Circle::area() const
   { return 3.14159 * radius * radius; }

// Output a Circle in the form:
// Center = [x, y]; Radius = #.##
ostream &operator<<(ostream &output, const Circle &c)
{  output << "Center = [" << c.x << ", " << c.y
          << "]; Radius = " << setiosflags(ios::showpoint)
          << setprecision(2) << c.radius;
   return output;   // enables concatenated calls
}
-----------------
// FIG9_4.CPP
// Casting base-class pointers to derived-class pointers
#include <iostream.h>
#include <iomanip.h>
#include "point.h"
#include "circle.h"

main()
{  Point *pointPtr, p(3.5, 5.3);
   Circle *circlePtr, c(2.7, 1.2, 8.9);
   cout << "Point p: " << p << endl << "Circle c: " << c << endl;

   // Treat a Circle as a Point (see only the base class part)
   pointPtr = &c;   // assign address of Circle to pointPtr
   cout << endl << "Circle c (via *pointPtr): " 
        << *pointPtr << endl;

   // Treat a Circle as a Circle (with some casting)
   pointPtr = &c;   // assign address of Circle to pointPtr
   circlePtr = (Circle *) pointPtr;  // cast base to derived
   cout << endl << "Circle c (via *circlePtr): " << endl
        << *circlePtr << endl << "Area of c (via circlePtr): "
        << circlePtr->area() << endl;

   // DANGEROUS: Treat a Point as a Circle
   pointPtr = &p;   // assign address of Point to pointPtr
   circlePtr = (Circle *) pointPtr;  // cast base to derived
   cout << endl << "Point p (via *circlePtr): "  
        << endl << *circlePtr << endl 
        << "Area of object circlePtr points to: "
        << circlePtr->area() << endl;
   return 0;
}
--------------------------------------------------------