From 7b19cabee8b08478f31f6e4594ed28e1d04e153c Mon Sep 17 00:00:00 2001
From: Syndamia <kamen@syndamia.com>
Date: Fri, 10 May 2024 10:10:21 +0300
Subject: [w11] Solved exercises

---
 week11/Exercise01/Set.hpp | 156 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 week11/Exercise01/Set.hpp

(limited to 'week11/Exercise01/Set.hpp')

diff --git a/week11/Exercise01/Set.hpp b/week11/Exercise01/Set.hpp
new file mode 100644
index 0000000..b83027f
--- /dev/null
+++ b/week11/Exercise01/Set.hpp
@@ -0,0 +1,156 @@
+#pragma once
+
+template <class T>
+class Set {
+	T* elements;
+	unsigned size;
+
+	void free();
+	void copyFrom(const Set& other);
+
+public:
+	Set();
+	~Set();
+	Set(const Set& other);
+	Set& operator=(const Set& other);
+	Set(Set&& other);
+	Set& operator=(Set&& other);
+
+	Set& operator+=(const Set& right);
+	template <class U>
+	friend Set<U> operator+(const Set<U>& left, const Set<U>& right);
+
+	Set& operator*=(const Set& right);
+	template <class U>
+	friend Set<U> operator*(const Set<U>& left, const Set<U>& right);
+
+	Set& operator-=(const Set& right);
+	template <class U>
+	friend Set operator-(const Set& left, const Set& right);
+};
+
+template <class T>
+void Set<T>::free() {
+	delete[] elements;
+}
+
+template <class T>
+void Set<T>::copyFrom(const Set& other) {
+	this->size = other.size;
+	this->elements = new T[size];
+	for (int i = 0; i < size; i++) {
+		this->elements[i] = other.elements[i];
+	}
+}
+
+template <class T>
+Set<T>::Set() {
+	elements = nullptr;
+	size = 0;
+}
+
+template <class T>
+Set<T>::~Set() {
+	delete[] elements;
+}
+
+template <class T>
+Set<T>::Set(const Set& other) {
+	copyFrom(other);
+}
+
+template <class T>
+Set<T>& Set<T>::operator=(const Set<T>& other) {
+	if (this != &other) {
+		free();
+		copyFrom(other);
+	}
+	return *this;
+}
+
+template <class T>
+Set<T>::Set(Set<T>&& other) {
+	this->size = other.size;
+	this->elements = other.elements;
+	other.elements = nullptr;
+}
+
+template <class T>
+Set<T>& Set<T>::operator=(Set<T>&& other) {
+	if (this != &other) {
+		free();
+
+		this->size = other.size;
+		this->elements = other.elements;
+		other.elements = nullptr;
+	}
+	return *this;
+}
+
+template <class T>
+Set<T>& Set<T>::operator+=(const Set<T>& right) {
+	T* biggerArray = new T[size + right.size];
+	for (int i = 0; i < size; i++) {
+		biggerArray[i] = elements[i];
+	}
+	for (int i = 0; i < right.size; i++) {
+		biggerArray[i+size] = right.elements[i];
+	}
+	delete[] elements;
+	elements = biggerArray;
+	size += right.size;
+
+	return *this;
+}
+
+template <class T>
+Set<T> operator+(const Set<T>& left, const Set<T>& right) {
+	Set<T> setUnion = left;
+	setUnion += right;
+	return setUnion;
+}
+
+template <class T>
+Set<T>& Set<T>::operator*=(const Set<T>& right) {
+	T* commonArray = new T[size];
+	unsigned commonCount = 0;
+	for (int i = 0; i < size; i++) {
+		for (int j = 0; j < right.size; j++) {
+			if (elements[i] == right.elements[j]) {
+				commonArray[commonCount++] = elements[i];
+				break;
+			}
+		}
+	}
+
+	size = commonCount;
+	delete[] elements;
+	elements = new T[size];
+	for (int i = 0; i < size; i++) {
+		elements[i] = commonArray[i];
+	}
+	delete[] commonArray;
+
+	return *this;
+}
+
+template <class T>
+Set<T> operator*(const Set<T>& left, const Set<T>& right) {
+	Set<T> setIntersection = left;
+	setIntersection *= right;
+	return setIntersection;
+}
+
+template <class T>
+Set<T>& Set<T>::operator-=(const Set& right) {
+	Set complement = right * (*this);
+	*this = complement;
+	return *this;
+}
+
+template <class T>
+Set<T> operator-(const Set<T>& left, const Set<T>& right) {
+	Set<T> setComplement = left;
+	setComplement -= right;
+	return setComplement;
+}
-- 
cgit v1.2.3