add new repoHEADmaster

1 files changed, 258 insertions, 0 deletions

diff --git a/Bachelor/Prog2/Z-Uebung/Teil3/shape.h b/Bachelor/Prog2/Z-Uebung/Teil3/shape.h
new file mode 100644
index 0000000..84f2b77
--- /dev/null
+++ b/Bachelor/Prog2/Z-Uebung/Teil3/shape.h
@@ -0,0 +1,258 @@
+// shape.h


+// Definition of classes Point, Shape, Polyline, 


+// Line, Polygon, Rectangle, Ellipse, Circle.


+


+#ifndef SHAPE_H


+#define SHAPE_H


+


+#include <sstream>


+using std::string;


+using std::stringstream;


+using std::ostream;


+


+#include <iostream>


+using std::cout;


+using std::endl;


+using std::cin;


+


+#include <cmath> // sqrt


+


+// class Point


+struct Point


+{


+   double x, y;


+   Point( double xx = 0.0, double yy = 0.0 )


+        : x( xx ), y( yy ) { }


+


+   double distance( const Point& p2 ) const


+   { 


+      double dx = x - p2.x,


+             dy = y - p2.y;


+      return sqrt( dx * dx + dy * dy );


+   }


+   string toString() const


+   {


+      stringstream sstream;


+      sstream << '(' << x << ", " << y << ')';


+      return sstream.str();


+   }


+   Point& operator*=( double c )


+   {  


+      x *= c; 


+      y *= c;  


+      return *this; 


+   }  


+};


+


+inline Point operator+( const Point& p1, const Point& p2 )


+{


+   return Point( p1.x + p2.x, p1.y + p2.y );


+}


+


+inline Point operator-( const Point& p1, const Point& p2 )


+{


+   return Point( p1.x - p2.x, p1.y - p2.y );


+}


+


+inline bool operator==( const Point& p1, const Point& p2 )


+{


+   return p1.x == p2.x && p1.y == p2.y;


+}


+


+inline bool operator!=( const Point& p1, const Point& p2 )


+{


+   return !( p1 == p2 );


+}


+


+inline ostream& operator<<( ostream& os, const Point& p )


+{


+   os << p.toString();   return os;


+}


+


+// class Shape


+class Shape


+{


+  protected:


+    Point anchor;  // anchor: point of reference for position of figure


+  public:


+    Shape( const Point& a = Point() ) : anchor( a ) { }


+    virtual ~Shape() { }


+


+    Point getAnchor() const  { return anchor; }


+    void setAnchor( Point a ) { anchor = a; }


+


+    void move( double dx, double dy )  // displacement


+    { anchor.x += dx; anchor.y += dy; }


+


+    virtual void scale( double scalingFactor ) = 0;


+    virtual void draw() const = 0;


+


+    virtual string toString() const


+    {


+       string str( "Shape-Anker: " );


+       return str += anchor.toString();


+    }


+};


+


+// class Polyline


+class Polyline : public Shape


+{


+  protected: 


+    Point* arrPoints;  // end-points of lines, relativ to anchor          


+    int nLines;        // number of line-segments == number of end-points


+                       


+  public:


+    Polyline( const Point& a = Point() )  // only one point


+            : Shape( a ), nLines( 0 ), arrPoints( NULL ) { }


+    Polyline( const Point& p1, const Point& p2 )  // one line


+            : Shape( p1 ), nLines( 1 )


+    {


+       arrPoints = new Point( p2 - p1 );


+    }


+    Polyline( Point arr[], int n );


+    Polyline( const Polyline& src );  // copy constructor


+    ~Polyline() { delete [] arrPoints; }  // destructor


+


+    Polyline& operator=( const Polyline& src );  // assignment


+


+    int getNumberOfLines() const { return nLines; } 


+    double getLength() const;


+    void scale( double scalingFactor );  // scaling


+    virtual void draw() const { }


+


+    Polyline& operator+=( const Point& p );     // appends a new point


+    Polyline& operator+=( const Polyline& pl ); // appends a new line


+                                               


+    string toString() const;


+};


+


+// class Line


+class Line : public Polyline


+{


+  public:


+    Line( Point a, Point b ) : Polyline( a, b ) { }


+    Line( double x1, double y1, double x2, double y2 )


+        : Polyline( Point( x1, y1 ), Point( x2, y2 ) ) { }


+  private:


+    Polyline& operator+=( const Point& );     // not allowed


+    Polyline& operator+=( const Polyline& );  // not allowed


+};


+


+// class Polygon


+class Polygon : public Polyline


+{


+  public:


+    Polygon( Point a = Point( 0, 0 ) ) : Polyline( a ) {}


+    Polygon( Point arr[], int n ) 


+           : Polyline( arr, n )


+    {}


+


+    int getNumberOfVertices() const


+    { 


+       if( nLines == 0 || arrPoints[ nLines - 1 ] != anchor )


+          return nLines + 1;


+       else 


+          return nLines;


+    }


+    int getNumberOfLines() const


+    { return getNumberOfVertices(); } 


+


+    double getCircumference() const


+    {


+       double len = Polyline::getLength();


+       if( nLines > 0 )


+          len += anchor.distance( anchor + arrPoints[ nLines - 1 ] );


+       return len;


+    }


+    double getLength() const { return getCircumference(); }


+};


+


+// class Rectangle


+class Rectangle : public Polygon  // rectangle


+{                                 // anchor: left lower corner


+  public:


+    Rectangle( Point lBottom, double w, double h )


+             : Polygon( lBottom )


+    {


+      nLines = 3;  // number of lines: nLines + 1 


+      arrPoints = new Point[ 3 ];


+      arrPoints[ 0 ] = Point( 0, h );


+      arrPoints[ 1 ] = Point( w, h );


+      arrPoints[ 2 ] = Point( w, 0 );


+    }


+    Rectangle( Point lBottom, Point rTop )


+    {


+      *this = Rectangle( lBottom, rTop.x - lBottom.x, rTop.y - lBottom.y );


+    }


+    double getHeight() const { return arrPoints[ 0 ].y; }


+    double getWidth() const  { return arrPoints[ 2 ].x; }


+    double getArea() const { return getHeight() * getWidth(); }


+


+  private:


+    Polyline& operator+=( const Point& );     // not allowed


+    Polyline& operator+=( const Polyline& );  // not allowed


+};


+


+// class Ellipse


+class Ellipse : public Shape  // anchor-centered ellipse


+{


+  protected:


+    double a, b;  // semi-major and semi-minor axis      


+                        


+  public:               


+    Ellipse( Point m, double aa, double bb )


+           : Shape( m ), a( aa ), b( bb )


+    { }


+    double getSemimajorAxis() const  { return a; }


+    double getSemiminorAxis() const  { return b; }


+    bool setSemimajorAxis( double aa )


+    {  


+       if( aa >= 0 ) { a = aa;  return true; }


+       else return false;


+    }


+    bool setSemiminorAxis( double bb )


+    {  


+       if( bb >= 0 ) { b = bb;  return true; }


+       else return false;


+    }


+    void scale( double scalingFactor )  // scaling


+    {


+       a  *= scalingFactor;  b *= scalingFactor;


+    }


+    virtual void draw() const { }


+    double getCircumference() const


+    {


+       return 3.14159 * ( 1.5 * ( a + b ) - sqrt( a * b ) ); 


+    }


+    string toString() const


+    {


+       stringstream sstream;


+       sstream << "Ellipsen-Mittelpunkt: " << anchor.toString() 


+               << "  Halbachsen: " << a << " und " << b; 


+       return sstream.str();


+    }


+};


+


+// class Circle


+class Circle : public Ellipse  // anchor-centered circle


+{


+  public:


+    Circle( Point m, double r )


+          : Ellipse( m, r, r )


+    { }


+    double getRadius() const  { return a; }


+    bool setRadius( double r )


+    {  


+       if( r >= 0 ) { a = r; b = r;  return true; }


+       else return false;


+    }


+    string toString() const


+    {


+       stringstream sstream;


+       sstream << "Kreis-Mittelpunkt: " << anchor.toString() 


+               << "  Radius: " << a;


+       return sstream.str();


+    }


+};


+


+#endif