restructured

seminar02_encapsulation/0circle/circle.cpp

@@ -0,0 +1,39 @@
+#include <iostream>
+#include <math.h>
+#include <cstdlib>
+#include "circle.h"
+#include "point.h"
+
+Circle::Circle(const Point& acenter, float aradius) {
+    mCenter = acenter;
+    mRadius = aradius;
+}
+Circle::Circle() {
+    mCenter = Point {0, 0};
+    mRadius = 1;
+}
+Circle::Circle(const Circle& circle) {
+   mCenter = circle.mCenter;
+   mRadius = circle.mRadius;
+}
+Point Circle::getCenter() const { return mCenter; }
+float Circle::getRadius() const { return mRadius; }
+
+void Circle::setCenter(const Point& p) {
+    mCenter = p;
+}
+void Circle::setRadius(float radius) {
+    mRadius = radius > 0 ? radius : 0;
+}
+float Circle::getArea() const {
+    return abs(mRadius * mRadius * M_PI);
+}
+float Circle::getDistance(const Point& p) {
+    return mCenter.distance(p) - mRadius; 
+}
+bool Circle::isColliding(const Circle& c) const {
+    return (mCenter.distance(c.getCenter()) - (mRadius + c.getRadius()) > 0) ? false : true;
+}
+void Circle::move(const Point& p) {
+    mCenter = mCenter + p;
+}

seminar02_encapsulation/0circle/circle.h

@@ -0,0 +1,23 @@
+#include "point.h"
+class Circle
+{
+private:
+	Point mCenter;
+	float mRadius;
+
+public:
+    Circle(const Point& acenter, float aradius);
+    Circle();
+    Circle(const Circle& circle);
+    Point getCenter() const;
+    float getRadius() const;
+
+    void setCenter(const Point& p); 
+    void setRadius(float radius); 
+    float getArea() const;
+    float getDistance(const Point& p);
+    bool isColliding(const Circle& c) const;
+    void move(const Point& p);
+};
+
+

seminar02_encapsulation/0circle/main.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include "point.h"
+#include "circle.h"
+
+using std::cout, std::endl;
+
+
+int main()
+{
+	Point p = {7, -1};
+	Point q = {-4, 2};
+	cout << "Point p = " << p << endl;
+	cout << "Point q = " << q << endl;
+	cout << "p + q = " << p + q << endl;
+
+
+	Circle a {{4, 1}, 3};
+	Circle b;
+    // b = a;
+
+	cout << "Circle a: center: " << a.getCenter() << " radius: " << a.getRadius() << endl; 
+	cout << "Circle b: center: " << b.getCenter() << " radius: " << b.getRadius() << endl;
+
+	cout << "Area of a = " << a.getArea() << endl;
+	cout << "Distance from point p to circle a = " << a.getDistance(p) << endl;
+
+
+
+	cout << "Collisions:" << endl;
+	if (a.isColliding(b))
+		cout << "Yes, a is colliding b" << endl;
+	else
+		cout << "No, a isn't colliding b" << endl;
+
+
+
+	cout << "Moving b by {1, 1}:" << endl;
+	b.move({1, 1});
+	if (a.isColliding(b))
+		cout << "Yes, a is colliding b" << endl;
+	else
+		cout << "No, a isn't colliding b" << endl;
+
+}

seminar02_encapsulation/0circle/point.cpp

@@ -0,0 +1,82 @@
+#include <iostream>
+#include <cmath>
+
+#include "point.h"
+
+
+Point::Point(float x, float y) 
+{
+    mx = x;
+    my = y;
+}
+
+Point::Point()
+{
+    mx = 0;
+    my = 0;
+}
+
+
+float Point::getX() const 
+{
+	return mx;
+}
+
+float Point::getY() const 
+{
+	return my;
+}
+
+void Point::setX(float x) 
+{
+	mx = x;
+}
+
+void Point::setY(float y) 
+{
+	my = y;
+}
+
+float Point::norm() const 
+{
+	return std::sqrt(mx * mx + my * my);
+}
+
+void Point::normalize() 
+{
+	float pnorm = norm();
+	mx /= pnorm;
+	my /= pnorm;
+}
+
+float Point::distance(const Point& p) const 
+{
+	return std::sqrt((p.mx - mx) * (p.mx - mx) + (p.my - my) * (p.my - my));
+}
+
+Point Point::operator+(const Point& right) const 
+{
+	Point result = {mx + right.mx, my + right.my};
+	return result;
+}
+
+Point Point::operator*(float a) const 
+{
+	Point result = {a * mx, a * my};
+	return result;
+}
+
+
+
+
+Point operator*(float a, const Point& p) 
+{
+	Point result = {a * p.mx, a * p.my};
+	return result;
+}
+
+std::ostream& operator<<(std::ostream& left, const Point& right) 
+{
+	left << "(" << right.mx << ", " << right.my << ")";
+	return left;
+}

seminar02_encapsulation/0circle/point.h

@@ -0,0 +1,37 @@
+#pragma once
+
+/*
+    Поля x и y сделаны приватными
+    Конкретно для этого класса их можно было сделать публичными
+    Так как пользователь всё-равно будет иметь доступ без ограничений к этим полям через геттеры и сеттеры
+    Но они сделаны приватными для образовательных целей
+*/
+
+class Point
+{
+private:
+    float mx, my;
+    
+public:
+
+    Point(float x, float y);
+    Point();
+
+    float getX() const;
+    float getY() const;
+    void setX(float x);
+    void setY(float y);
+
+    void normalize();
+    float distance(const Point& p) const;
+    float norm() const;
+    Point operator+(const Point& right) const;
+    Point operator*(float a) const;
+
+
+
+    friend Point operator*(float a, const Point& p);
+    friend std::ostream& operator<<(std::ostream& left, const Point& right);
+};
+
+