#include <iostream>
#include <ctime>
#include <cstdlib>
//#include <string

using namespace std;

const double PI = atan(1.0) * 4;

class Dot {
	double x;
	double y;
public:
	Dot() { x = 0; y = 0; }
	Dot(double coord1, double coord2) { x = coord1; y = coord2; }
	Dot(const Dot& obj) { x = obj.x; y = obj.y; }
	void set_x(double coord) { x = coord; }
	void set_y(double coord) { y = coord; }
	double get_x() { return x; }
	double get_y() { return y; }
};

class Circle :virtual public Dot {
	double radius;
public:
	Circle() { radius = 1; }
	Circle(double coord1, double coord2, double r) : Dot(coord1, coord2) { radius = r; }
	Circle(const Circle& obj) { radius = obj.radius; }
	void set_radius(double r) { radius = r; }
	double get_radius() { return radius; }
};

class Rhombus :virtual public Dot {
	double side;
public:
	Rhombus() { side = 1; }
	Rhombus(double coord1, double coord2, double s) : Dot(coord1, coord2) { side = s; }
	Rhombus(const Rhombus& obj) { side = obj.side; }
	void set_side(double s) { side = s; }
	double get_side() { return side; }
};

class CircleInRhombus :public Circle, public Rhombus {
	double square;
	string str;
	char* arr;
	char* generate_string();
	void set_square() { square = 2 * get_side() * get_radius() - PI * pow(get_radius(), 2); }
public:
	CircleInRhombus() { square = 1; arr = generate_string(); str = arr; }
	CircleInRhombus(double coord1, double coord2, double r, double s) : Circle(coord1, coord2, r), Rhombus(coord1, coord2, s) { set_square(); arr = generate_string(); str = arr; cout << "Constructing\n"; }
	CircleInRhombus(const CircleInRhombus& obj) {
		if (arr) {
			delete[] arr;
		}
		arr = new char[strlen(obj.arr) + 1];
		strcpy_s(arr, strlen(obj.arr) + 1, obj.arr);
		str = obj.str;
		square = obj.square;
	}
	~CircleInRhombus() { cout << "Destructing\n"; delete[] arr; }
	double get_square() { return square; }
	string get_str() { return str; }
	char* get_arr() { return arr; }
};

class ShapesContainer {
	CircleInRhombus* array;
	unsigned __int32 size;
public:
	ShapesContainer() { size = 1; array = new CircleInRhombus[size]; }
	~ShapesContainer() { delete [] array; }
	void add(CircleInRhombus& obj);
	unsigned __int32 get_size() { return size; }
	CircleInRhombus& operator[](unsigned __int32 index);
	CircleInRhombus* get_array() { return array; }
};

char* CircleInRhombus::generate_string() {;
	int size = rand() % 1000;
	arr = new char[size + 1];
	for (unsigned int i = 0; i < size; i++) {
		arr[i] = 'a' + rand() % ('z' - 'a');
	}
	arr[size] = '\0';
	return arr;
}

void ShapesContainer::add(CircleInRhombus& obj) {
	CircleInRhombus* temp = new CircleInRhombus[size + 1];
	if (!temp) {
		cout << "Allocation error.\n";
		exit(1);
	}
	for (unsigned __int32 i = 1; i < size - 1; i++) {
		temp[i] = array[i];
	}
	temp[size - 1] = obj;
	delete[] array;
	array = temp;
	size++;
}

CircleInRhombus& ShapesContainer::operator[](unsigned __int32 index){
	if (index < 0 || index >= size) {
		cout << "Bound Error.\n";
		exit(1);
	}
	return array[index];
}

double average(ShapesContainer& obj) {
	double num = 0;
	for (unsigned __int32 i = 0; i < obj.get_size(); i++) {
		num += 1 / obj[i].get_square();
	}
	return obj.get_size() / num;
}

CircleInRhombus generate() {
	double radius, side;
	do {
		radius = rand() % 100;
		side = rand() % 100;
	} while (side < radius * PI / 2);
	CircleInRhombus temp(rand() % 100, rand() % 100, radius, side);
	return temp;
}

int compare_char(CircleInRhombus* obj1, CircleInRhombus* obj2) {
	return strcmp(obj1->get_arr(), obj2->get_arr());
}

int compare_string(CircleInRhombus* obj1, CircleInRhombus* obj2) {
	return obj1->get_str().compare(obj2->get_str());
}

int main() {
	srand(time(NULL));
	ShapesContainer obj;
	for (unsigned __int32 i = 0; i < 5; i++) {
		CircleInRhombus temp(generate());
		obj.add(temp);
	}
	cout << average(obj) << endl;
	//qsort(obj.get_array(), obj.get_size(), sizeof(CircleInRhombus), (int(*) (const void*, const void*))compare_char);
	for (int i = 0; i < 5; i++) {
		cout << obj[i].get_arr() << endl;
	}
	return 0;
}