From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- Bachelor/Prog2/Z-Uebung/Teil4/shape.h | 265 ++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 Bachelor/Prog2/Z-Uebung/Teil4/shape.h (limited to 'Bachelor/Prog2/Z-Uebung/Teil4/shape.h') diff --git a/Bachelor/Prog2/Z-Uebung/Teil4/shape.h b/Bachelor/Prog2/Z-Uebung/Teil4/shape.h new file mode 100644 index 0000000..9b84b3b --- /dev/null +++ b/Bachelor/Prog2/Z-Uebung/Teil4/shape.h @@ -0,0 +1,265 @@ +// shape.h +// Definition of classes Point, Shape, Polyline, +// Line, Polygon, Rectangle, Ellipse, Circle +// including virtual method clone() + +#ifndef SHAPE_H +#define SHAPE_H + +#include +using std::string; +using std::stringstream; +using std::ostream; + +#include +using std::cout; +using std::endl; +using std::cin; + +#include // 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() { cout << "Shape-Destruktor" << endl; } + + 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(); + } + virtual Shape* clone() const = 0; +}; + +// 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; + Shape* clone() const { return new Polyline( *this ); } +}; + +// 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 ) ) { } + Shape* clone() const { return new Line( *this ); } + + 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(); } + Shape* clone() const { return new Polygon( *this ); } +}; + +// 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(); } + Shape* clone() const { return new Rectangle( *this ); } + + 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(); + } + Shape* clone() const { return new Ellipse( *this ); } +}; + +// 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(); + } + Shape* clone() const { return new Circle( *this ); } +}; + +#endif -- cgit v1.2.3